在本章中，我们将深入探讨C++中的多线程编程。多线程是现代软件开发的重要组成部分，能够显著提高程序的性能和响应速度。我们将介绍如何使用C++标准库中的<thread>头文件来创建和管理线程，并讨论一些常见的多线程问题，如数据竞争和死锁。
创建线程
创建一个线程的基本步骤包括导入必要的头文件、定义线程函数以及启动线程。下面是一个简单的例子：
// www.javascriptcn.com code example
#include <iostream>
#include <thread>
// 定义线程函数
void threadFunction() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
// 创建并启动线程
std::thread myThread(threadFunction);
// 等待线程完成
myThread.join();
return 0;
}在这个例子中，我们首先导入了<thread>头文件，然后定义了一个简单的线程函数threadFunction。在main函数中，我们创建了一个线程对象myThread并将threadFunction作为参数传递给它，从而启动了这个线程。最后，我们调用了join()方法来等待线程结束。
线程参数与返回值
线程可以接受参数并返回结果。通过将参数传递给线程函数，我们可以让线程处理不同的任务。同样，我们也可以通过一些机制（例如共享内存或消息队列）来获取线程的结果。
传递参数
你可以通过多种方式向线程函数传递参数，以下是其中两种方法：
使用引用参数
// www.javascriptcn.com code example
#include <iostream>
#include <thread>
void threadFunction(int& num) {
++num;
std::cout << "Number in thread: " << num << std::endl;
}
int main() {
int number = 42;
std::thread myThread(threadFunction, std::ref(number));
myThread.join();
std::cout << "Final number: " << number << std::endl;
return 0;
}在这个例子中，我们通过std::ref将number变量的引用传递给线程函数，使得线程可以修改主函数中的变量。
使用lambda表达式
// www.javascriptcn.com code example
#include <iostream>
#include <thread>
int main() {
int number = 42;
std::thread myThread([=, &number](){
++number;
std::cout << "Number in thread: " << number << std::endl;
});
myThread.join();
std::cout << "Final number: " << number << std::endl;
return 0;
}这里我们使用lambda表达式捕获变量，并在线程函数中修改它们。
返回值
C++标准库中的std::thread并不直接支持线程函数返回值，但可以通过其他方式实现这一功能。例如，你可以使用全局变量、共享内存或通过回调函数来传递结果。
线程同步
当多个线程同时访问共享资源时，可能会导致数据竞争或死锁等问题。为了防止这些问题，我们需要使用线程同步机制。
互斥量（Mutex）
互斥量是一种基本的同步原语，用于保护共享资源不被多个线程同时访问。
// www.javascriptcn.com code example
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 全局互斥量
void printBlock(int n, char c) {
mtx.lock();
for (int i = 0; i < n; ++i) {
std::cout << c;
}
std::cout << '\n';
mtx.unlock();
}
int main() {
std::thread th1(printBlock, 50, '*');
std::thread th2(printBlock, 50, '$');
th1.join();
th2.join();
return 0;
}在这个例子中，我们使用std::mutex来确保每次只有一个线程可以执行打印操作，避免了数据竞争。
条件变量（Condition Variable）
条件变量允许线程等待某个条件变为真。这在多线程环境中非常有用，比如当一个线程需要等待另一个线程完成某些工作后才能继续执行。
// www.javascriptcn.com code example
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void printId(int id) {
std::unique_lock<std::mutex> lck(mtx);
while (!ready) cv.wait(lck); // 等待条件变为true
std::cout << "Thread " << id << std::endl;
}
void go() {
{
std::lock_guard<std::mutex> lck(mtx);
ready = true;
}
cv.notify_all(); // 唤醒所有等待的线程
}
int main() {
std::thread threads[10];
for (int i = 0; i < 10; ++i)
threads[i] = std::thread(printId, i + 1);
std::cout << "10 threads ready to race...\n";
go();
for (auto& th : threads) th.join();
return 0;
}在这个示例中，printId函数中的线程会等待ready变量变为true。go函数将ready设置为true并唤醒所有等待的线程。
死锁与避免
死锁是多线程编程中常见的问题之一，当两个或更多的线程在等待对方持有的锁时就会发生死锁。为了避免死锁，应遵循以下原则：
- 按照相同的顺序锁定资源。
- 尽量减少持有锁的时间。
- 使用超时机制尝试获取锁。
示例：避免死锁
// www.javascriptcn.com code example
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtxA, mtxB;
void funcA() {
std::lock_guard<std::mutex> lockA(mtxA);
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时操作
std::lock_guard<std::mutex> lockB(mtxB);
std::cout << "funcA completed." << std::endl;
}
void funcB() {
std::lock_guard<std::mutex> lockB(mtxB);
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时操作
std::lock_guard<std::mutex> lockA(mtxA);
std::cout << "funcB completed." << std::endl;
}
int main() {
std::thread t1(funcA);
std::thread t2(funcB);
t1.join();
t2.join();
return 0;
}在这个例子中，两个函数分别按照固定的顺序锁定互斥量，从而避免了死锁的发生。
总结
在本章中，我们学习了如何使用C++创建和管理线程，包括如何传递参数、返回值以及如何使用同步机制来避免数据竞争和死锁。掌握这些概念对于构建高效且可靠的多线程应用程序至关重要。
接下来，我们将进一步探索更复杂的多线程应用场景，并讨论如何利用现代C++特性来简化多线程编程。