C++语言的并发编程

萧蕊旖

于 2025-02-10 00:38:03 发布

阅读量366

点赞数 3

分类专栏：包罗万象文章标签： golang 开发语言后端

本文链接：https://blog.youkuaiyun.com/2501_90485539/article/details/145539863

版权

包罗万象专栏收录该内容

29 篇文章

订阅专栏

C++语言的并发编程

引言

随着多核处理器的普及，程序的并发性成为现代软件开发中不可或缺的一部分。C++作为一种强大的系统编程语言，其对并发编程的支持不断增强。从C++11开始，C++标准库引入了许多与并发相关的新特性，包括线程、互斥量、条件变量等，使得并发编程更为简单和高效。但要真正掌握并发编程的精髓，我们需要深入了解其基本概念、技术要点以及常见的陷阱与解决方案。

并发编程基础

1. 什么是并发

并发是指在同一时间段内执行多个任务的能力。与并行不同，并行强调同时在多个处理器上执行任务，而并发更注重任务之间的交互与协作。在C++中，通过创建多个线程来实现并发。

2. 线程的概念

线程是进程中的一个执行单元，线程之间共享内存空间，但每个线程有自己的执行栈和寄存器状态。在C++中，我们可以利用标准库提供的线程支持来创建和管理线程。

3. C++中的线程

在C++11中，std::thread类被引入，用于创建和管理线程。基本的线程使用方式如下：

```cpp

include

void threadFunction() { std::cout << "Hello from thread!" << std::endl; }

int main() { std::thread t(threadFunction); // 创建线程 t.join(); // 等待线程结束 return 0; } ```

在上述示例中，我们定义了一个简单的线程函数threadFunction，并在main函数中创建了一个线程t。通过调用t.join()，主线程会等待线程t执行完毕。

线程的管理

1. 创建线程

我们可以通过std::thread类的构造函数创建线程，并将可调用对象作为参数传递给它。可调用对象可以是函数指针、函数对象或lambda表达式。

```cpp auto lambda = { std::cout << "Hello from lambda!" << std::endl; };

std::thread t(lambda); t.join(); ```

2. 线程的参数传递

在创建线程时，我们可以通过引用或值传递参数。在C++中，如果希望传递对象的引用，仍然可以使用std::ref进行包装。

```cpp

include

void increment(int& value) { ++value; }

int main() { int x = 0; std::thread t(increment, std::ref(x)); // 传递引用 t.join(); std::cout << "x = " << x << std::endl; // x = 1 return 0; } ```

3. 线程的同步

当多个线程并发访问共享资源时，就会引发数据竞争问题。这时，我们需要使用同步机制来保护共享数据。C++标准库提供了多种同步机制，包括互斥量、条件变量等。

互斥量（Mutex）

互斥量是最常用的同步机制，通过std::mutex类来实现。互斥量可以确保同一时刻只有一个线程在访问保护的资源。

```cpp

include

std::mutex mtx; // 定义互斥量 int shared_data = 0;

void threadFunction() { std::lock_guard lock(mtx); // 自动加锁和解锁 ++shared_data; }

int main() { std::thread t1(threadFunction); std::thread t2(threadFunction); t1.join(); t2.join(); std::cout << "shared_data = " << shared_data << std::endl; // shared_data = 2 return 0; } ```

在上述示例中，我们使用std::lock_guard来自动管理互斥量的加锁和解锁，确保线程安全。

条件变量（Condition Variable）

条件变量用于线程间的通知和协作，当某个条件不满足时，线程可以等待条件变量的通知。

```cpp

include

std::mutex mtx; std::condition_variable cv; bool ready = false;

void worker() { std::cout << "Waiting..." << std::endl; std::unique_lock lock(mtx); cv.wait(lock, [] { return ready; }); // 等待条件变量 std::cout << "Worker is done!" << std::endl; }

int main() { std::thread t(worker); std::this_thread::sleep_for(std::chrono::seconds(2)); { std::lock_guard lock(mtx); ready = true; // 改变条件 } cv.notify_one(); // 通知等待线程 t.join(); return 0; } ```

在此示例中，工作线程在条件变量上等待，直到主线程修改状态并通知它为止。

线程安全的设计

1. 数据竞争

数据竞争是指多个线程同一时间访问相同的共享数据且至少有一个线程在修改该数据。解决数据竞争的主要方法是使用互斥量等同步机制。

2. 死锁

死锁是指两个或多个线程因争夺资源而造成的相互等待的状态，导致所有线程都无法继续执行。为了避免死锁，可以使用以下几种策略：

资源有序分配：确保所有线程以相同的顺序请求资源。
时间限制：给线程请求资源设置时间限制，超时则放弃。
避免持有锁的时间过长：尽量减少在持有锁的情况下执行的代码量。

3. 活锁

活锁与死锁相似，但线程并没有阻塞，而是因为不断重复相同的操作而无法继续进展。解决活锁的一种方法是让线程在重新尝试之前休眠一段时间。

高级并发特性

1. 原子操作

原子操作是一种不可分割的操作，多个线程同时执行时不会相互干扰。在C++11中，std::atomic提供了对基本数据类型的原子操作支持。

```cpp

include

std::atomic counter(0);

void increment() { for (int i = 0; i < 1000; ++i) { ++counter; // 原子操作 } }

int main() { std::thread t1(increment); std::thread t2(increment); t1.join(); t2.join(); std::cout << "Counter = " << counter << std::endl; // Counter = 2000 return 0; } ```

2. 未来和承诺（Future and Promise）

std::promise和std::future提供了一种机制，可以在异步操作中传递结果或错误。通过std::promise设定值后，std::future可以获取这个值。

```cpp

include

int calculate() { std::this_thread::sleep_for(std::chrono::seconds(1)); return 42; // 返回结果 }

int main() { std::future result = std::async(std::launch::async, calculate); // 异步启动 std::cout << "Calculating..." << std::endl; std::cout << "Result: " << result.get() << std::endl; // 等待获取结果 return 0; } ```