随着计算机硬件技术的不断发展，多核处理器已经成为了主流。同时，多线程编程也成为了现代软件开发中的一个关键技巧，能够有效地提高程序的性能和响应能力。C++11引入了一个强大的多线程库std::thread，可以简化多线程编程的复杂性。本篇博客将为大家介绍std::thread的基本使用方法和一些常见的注意事项。
1. 基本使用方法
std::thread的使用非常简单，只需包含头文件
#include <iostream>
#include <thread>
void printHello() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
std::thread t(printHello);
t.join();
return 0;
}
在上面的代码中，我们定义了一个名为printHello的函数，该函数用于在新线程中输出"Hello from thread!"。在主线程中，我们创建了一个std::thread对象t，并将printHello函数传递给它的构造函数。然后，通过调用t.join()，我们等待新线程的执行完成。最后，我们在主线程中返回0，表示程序成功结束。
2. 传递参数
如果需要在新线程中执行的函数带有参数，我们可以使用std::thread对象的构造函数来将参数传递给函数。例如：
#include <iostream>
#include <thread>
void printMessage(const std::string& message) {
std::cout << "Message: " << message << std::endl;
}
int main() {
std::string message = "Hello from thread!";
std::thread t(printMessage, message);
t.join();
return 0;
}
在上面的代码中，我们定义了一个名为printMessage的函数，该函数带有一个参数message。在主线程中，我们创建了一个std::thread对象t，并将printMessage函数和message参数传递给它的构造函数。
需要注意的是，在使用std::thread对象的构造函数传递参数时，参数会被拷贝到新线程的内存空间中。因此，如果参数是一个较大的对象，这将导致不必要的开销。为了避免这种情况，可以使用std::ref()函数对对象进行引用传递。例如：
#include <iostream>
#include <thread>
#include <functional>
void printMessage(const std::string& message) {
std::cout << "Message: " << message << std::endl;
}
int main() {
std::string message = "Hello from thread!";
std::thread t(printMessage, std::ref(message));
t.join();
return 0;
}
在上面的代码中，我们使用了std::ref()函数对message参数进行了引用传递。这样，新线程中的函数将直接使用主线程中的message对象，而不会开辟新的内存空间。
3. 线程的生命周期
使用std::thread创建的线程对象有一个重要的特性：在std::thread对象的析构函数被调用之前，必须调用std::thread对象的join()或detach()函数来结束线程的执行。如果未调用这两个函数的任何一个，并且std::thread对象被销毁，则程序将会终止。
- join()函数会阻塞当前线程，直到被调用的std::thread对象执行完成。
- detach()函数将std::thread对象从当前线程中分离，使其成为一个单独的线程并使其在后台运行。
下面是一个示例代码，演示了join()函数的使用方法：
#include <iostream>
#include <thread>
void printHello() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
std::thread t(printHello);
// 等待新线程完成执行
t.join();
std::cout << "Hello from main thread!" << std::endl;
return 0;
}
在上面的代码中，我们首先创建了一个std::thread对象t，并使用join()函数来等待新线程的执行完成。然后，在主线程中输出"Hello from main thread!"。
需要注意的是，如果未调用join()或detach()函数来结束线程的执行，并且std::thread对象被销毁，则程序将会终止，这可能导致一些未定义行为或内存泄漏的问题。因此，确保在std::thread对象生命周期结束之前，调用了这两个函数中的一个。
4. 线程的同步
在多线程编程中，线程之间的数据共享是一个重要的问题。当多个线程同时访问共享数据时，可能会引发一些竞态条件和数据不一致的问题。为了解决这些问题，C++11提供了一些同步原语，用于确保多线程的互斥和同步。
最常用的同步原语是std::mutex和std::lock_guard。std::mutex是一个互斥量，用于保护共享数据的访问，而std::lock_guard是一个用于管理std::mutex的RAII封装器。
下面是一个示例代码，演示了如何使用std::mutex和std::lock_guard来保护共享数据的访问：
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
void incrementCounter(int& counter) {
std::lock_guard<std::mutex> lock(mtx);
counter++;
}
int main() {
int counter = 0;
std::thread t1(incrementCounter, std::ref(counter));
std::thread t2(incrementCounter, std::ref(counter));
t1.join();
t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;
}
在上面的代码中，我们首先定义了一个std::mutex对象mtx，用于保护共享数据counter的访问。然后，我们定义了一个名为incrementCounter的函数，该函数使用std::lock_guard对互斥量进行了加锁，然后递增counter的值。
在主线程中，我们创建了两个std::thread对象t1和t2，分别调用incrementCounter函数来递增counter的值。通过调用std::ref(counter)，确保了counter参数以引用传递的方式被传递给了新线程中的函数。
最后，我们调用t1.join()和t2.join()来等待新线程的执行完成，并在主线程中输出最终的counter值。
需要注意的是，在多线程中访问共享数据时，一定要确保对临界区的访问是互斥的，以避免竞态条件和数据不一致的问题。另外，应该灵活地使用同步原语，以避免过度使用锁而导致性能下降。
5. 多线程编程的注意事项
在多线程编程中，还有一些常见的注意事项需要我们关注：
-
线程之间的调度是不确定的：并发执行的线程之间的相对执行顺序是不确定的，因此在编写多线程代码时要确保不依赖于线程之间的执行顺序。
-
共享数据竞争：当多个线程同时访问共享数据时，可能会引发一些竞态条件和数据不一致的问题。为了解决这些问题，可以使用同步原语，如互斥量和条件变量。
-
阻塞操作的注意事项：当一个线程因为某些原因被阻塞时，其他线程应该继续执行，以充分利用多核处理器的性能。在C++中，通过使用非阻塞的I/O操作，或使用异步操作和回调函数，可以避免阻塞线程，提高程序的响应能力。
-
死锁问题：当多个线程相互等待对方释放锁资源时，可能会导致死锁的问题。为了避免死锁，应该遵循一定的锁顺序，并避免在持有锁的情况下请求其他锁。
-
线程安全的编程：在多线程编程中，需要确保代码的线程安全性。线程安全的函数能够在多个线程同时调用时正常工作，而无需任何额外的同步措施。可以使用原子操作和锁来实现线程安全的数据结构和算法。
结论
C++11的多线程库std::thread为多线程编程提供了强大的支持。通过简单地包含头文件
然而，多线程编程也是一个复杂的任务，需要我们对线程、锁、同步原语等概念有一定的了解。同时，还需要根据实际情况，合理地进行线程的设计和调度，以充分利用计算机硬件的性能。
希望本篇博客能够为大家提供一些关于C++11多线程库std::thread的使用指南，并帮助大家更好地理解和应用多线程编程的技巧。
本文来自极简博客，作者：编程艺术家，转载请注明原文链接：C++11多线程库std::thread使用指南
