C++11 Thead线程库的基本使用

文章目录

• 创建线程
• 传递参数
• 等待线程完成
• 分离线程
• joinable()

  创建线程

  要创建线程，我们需要一个可调用的函数或函数对象，作为线程的入口点。在C++11中，我们可以使用函数指针、函数对象或lambda表达式来实现。

  创建线程的基本语法如下：

  #include //头文件
  using namespace std;
  thread t(function_name, args...);
  `function_name`是线程入口点的函数或可调用对象
  `args...`是传递给函数的参数
  

  创建线程后，我们可以使用t.join()等待线程完成，或者使用t.detach()分离线程，让它在后台运行。

  #include #include using namespace std;
  void print_message() 
  { cout << "Hello, world!" << endl;
  }
  int main() 
  { std::thread t(print_message); 
  	t.join();
      return 0;
  }
  

  我们定义了一个名为print_message的函数，它输出一条消息。

  然后，我们创建了一个名为t的线程，将print_message函数作为入口点。

  最后，我们使用t.join()等待线程完成。

  传递参数

  我们可以使用多种方式向线程传递参数，例如使用函数参数、全局变量、引用等。如：

  #include #include using namespace std;
  void print_message(const string& message)
  { cout << message << endl;
  }
  void increment(int& x)
  { ++x;
  }
  int main() 
  { string message = "Hello, world!";
      thread t(print_message, message);
      t.join(); 
  	int x = 0;  
      thread t2(increment, ref(x));  
  	t2.join();  
  	cout << x << endl;
      return 0;
  }
  

  在第一个例子中，我们使用了一个字符串作为函数参数，传递给线程。

  在第二个例子中，我们使用了一个引用来传递一个整数变量。

  需要注意的是，当我们使用引用传递参数时，我们需要使用std::ref来包装引用，否则编译器会报错。

  等待线程完成

  当我们创建一个线程后，我们可能需要等待它完成，以便获取线程的执行结果或执行清理操作。我们可以使用t.join()方法来等待线程完成。

  例如，下面的代码创建了两个线程，等待它们完成后输出一条消息：

  #include #include using namespace std;
  void print_message(const std::string& message) 
  { std::cout << message << std::endl;
  }
  int main() 
  { thread t1(print_message, "Thread 1");  
   thread t2(print_message, "Thread 2");  
   t1.join();  
   t2.join();  
   cout << "All threads finished!" << endl;  
   return 0;
   }
  

  在这个例子中，我们创建了两个线程t1和t2，它们都调用print_message函数输出一条消息。

  然后，我们使用t1.join()和t2.join()等待它们完成。最后，我们输出一条消息，表示所有线程都已经完成。

  分离线程

  有时候我们可能不需要等待线程完成，而是希望它在后台运行。

  这时候我们可以使用t.detach()方法来分离线程。

  例如，下面的代码创建了一个线程，分离它后输出一条消息：

  #include #include using namespace std;
  void print_message(const std::string& message)
  { cout << message << endl;
  }
   int main() 
  { thread t(print_message, "Thread 1");
   t.detach(); 
   cout << "Thread detached" << endl;
   return 0;
  }
  

  在这个例子中，我们创建了一个名为t的线程，调用print_message函数输出一条消息。

  然后，我们使用t.detach()方法分离线程，让它在后台运行。

  最后，我们输出一条消息，表示线程已经被分离。

  需要注意的是，一旦线程被分离，就不能再使用t.join()方法等待它完成。

  而且，我们需要确保线程不会在主线程结束前退出，否则可能会导致未定义行为。

  joinable()

  joinable()方法返回一个布尔值，如果线程可以被join()或detach()，则返回true，否则返回false。

  如果我们试图对一个不可加入的线程调用join()或detach()，则会抛出一个std::system_error异常。

  下面是一个使用joinable()方法的例子：

  #include #include using namespace std;
  void foo() 
  { cout << "Thread started" << endl;
  }
  int main() 
  { thread t(foo);
      if (t.joinable())
  	{ t.join();
      }
      cout << "Thread joined" << endl;
      return 0;
  }
  

  本文是作为自己的一个学习记录，学习的资源来源于链接