随着计算机硬件性能的不断提升，多核处理器成为常态，充分利用多核CPU的计算能力已成为提高应用程序性能的关键。在这种背景下，并发编程显得尤为重要。C++11 提供了强大的多线程支持，使得在 C++ 中实现高效的并发程序变得更加简单和直观。

本文将深入探讨 C++11 中的线程和锁机制，帮助开发者理解如何利用这些特性进行高效并发编程，并避免常见的陷阱。

1. C++11 中的线程（std::thread）

C++11 引入了 std::thread 类，用于在程序中启动和管理线程。std::thread 提供了一种简单的方式来创建和管理多个线程，并且能够轻松地与其他线程进行同步。

1.1 创建线程

要创建一个线程，我们只需要实例化一个 std::thread 对象，并将要执行的函数传递给它。以下是一个简单的例子，展示了如何使用 std::thread 创建并启动一个线程：

#include <iostream> #include <thread> void print_message() { std::cout << "Hello from thread!" << std::endl; } int main() { std::thread t(print_message); // 创建并启动线程 t.join(); // 等待线程完成 return 0; }

在上面的代码中，std::thread t(print_message); 创建了一个新的线程，并执行 print_message 函数。t.join(); 确保主线程会等待新线程完成。

1.2 线程参数传递

std::thread 可以传递参数给线程函数。如果传递的参数是引用类型，需要使用 std::ref 来显式地传递引用：

#include <iostream> #include <thread> void print_message(int i) { std::cout << "Thread number: " << i << std::endl; } int main() { for (int i = 0; i < 5; ++i) { std::thread t(print_message, i); // 启动多个线程，每个线程传递不同的参数 t.join(); // 等待线程完成 } return 0; }

每个线程接收到不同的整数作为参数，并输出相应的消息。

2. 线程同步与互斥：std::mutex 和 std::lock_guard

在并发编程中，多个线程访问共享资源时，容易导致数据竞争和不一致的状态。为了避免这种情况，C++11 提供了 std::mutex（互斥锁）来保护共享资源，确保同一时刻只有一个线程可以访问共享资源。

2.1 使用 std::mutex 进行锁定

std::mutex 是最基本的互斥锁，它允许线程在执行某些代码块时对共享资源进行独占访问。要保护共享资源，我们需要在访问共享资源的代码块前后加锁和解锁。

#include <iostream> #include <thread> #include <mutex> std::mutex mtx; // 创建一个全局互斥锁 int counter = 0; void increment() { mtx.lock(); // 加锁，确保其他线程不能同时访问共享资源 ++counter; mtx.unlock(); // 解锁 } int main() { std::thread t1(increment); std::thread t2(increment); t1.join(); t2.join(); std::cout << "Final counter value: " << counter << std::endl; return 0; }

在这个例子中，mtx.lock() 和 mtx.unlock() 分别用于加锁和解锁 counter 变量，确保 counter 变量不会被多个线程同时修改，避免了数据竞争。

2.2 使用 std::lock_guard 自动管理锁

直接使用 lock() 和 unlock() 可能导致忘记解锁，从而产生死锁问题。为了解决这个问题，C++11 提供了 std::lock_guard，它是一个自动管理锁的工具。使用 std::lock_guard 时，只需要在作用域内创建它，它会在作用域结束时自动释放锁。

#include <iostream> #include <thread> #include <mutex> std::mutex mtx; int counter = 0; void increment() { std::lock_guard<std::mutex> guard(mtx); // 自动加锁和解锁 ++counter; } int main() { std::thread t1(increment); std::thread t2(increment); t1.join(); t2.join(); std::cout << "Final counter value: " << counter << std::endl; return 0; }

在这个例子中，std::lock_guard<std::mutex> guard(mtx); 自动加锁，并在 guard 对象超出作用域时自动释放锁。这种方式避免了忘记解锁的风险，使代码更加简洁和安全。

3. 条件变量：std::condition_variable

在并发编程中，某些线程可能需要等待特定条件的发生才能继续执行。C++11 提供了 std::condition_variable 来实现线程间的同步和通知机制。

3.1 std::condition_variable 的使用

假设我们有一个生产者-消费者问题，生产者线程不断生产数据，消费者线程在数据可用时进行消费。通过使用 std::condition_variable，我们可以让消费者线程等待生产者线程发出信号。

#include <iostream> #include <thread> #include <mutex> #include <condition_variable> std::mutex mtx; std::condition_variable cv; int data = 0; void producer() { std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟生产延迟 std::lock_guard<std::mutex> guard(mtx); data = 42; // 生产数据 cv.notify_one(); // 通知消费者线程 } void consumer() { std::cout << "Consumer waiting for data...\n"; std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, [] { return data != 0; }); // 等待数据可用 std::cout << "Consumed data: " << data << std::endl; } int main() { std::thread t1(producer); std::thread t2(consumer); t1.join(); t2.join(); return 0; }

在这个例子中，消费者线程使用 cv.wait() 来等待生产者线程通知数据已经准备好。当生产者线程生产数据后，调用 cv.notify_one() 来通知消费者线程。

4. 总结

C++11 中的线程和同步机制提供了强大的工具来开发高效、可靠的并发程序。通过 std::thread 启动线程，使用 std::mutex 和 std::lock_guard 进行线程同步，借助 std::condition_variable 实现线程间的协调，可以有效地管理并发操作，避免数据竞争和死锁问题。理解并灵活应用这些工具，可以帮助开发者编写出更高效和可维护的并发程序。

并发编程虽强大，但也伴随着复杂性，开发者需要时刻关注资源管理、死锁、竞争条件等问题。在多核时代，掌握这些技术将使你能够开发出更高效的应用程序。