C++语言的并发编程_c++并发编程-优快云博客

本文链接：https://blog.youkuaiyun.com/2501_90181655/article/details/144996680

C++语言的并发编程

引言

随着计算机硬件的快速发展，单核CPU的性能提升已经逐渐放缓，多核处理器逐渐成为主流。这使得并发编程成为了软件开发中的一个重要领域。在并发编程中，我们可以充分利用多核CPU的性能，实现更高效的程序。C++作为一种强大的系统编程语言，提供了丰富的工具和库来支持并发编程。在这篇文章中，我们将探讨C++并发编程的基本概念、主要工具和库，以及一些实践中的注意事项。

一、并发编程的基本概念

1.1 并发与并行的区别

并发（Concurrency）和并行（Parallelism）是两个常被混淆的概念。并发指的是在同一个时间段内多个任务的执行，不一定同时进行，比如一个CPU可以快速切换任务，实现并发。而并行则是在同一时刻执行多个任务，要求有多个处理器或核心同时工作。因此，并发是实现并行的基础，但并行不仅仅依赖于并发。

1.2 线程与进程

在计算机中，程序的执行是以进程为单位进行的。进程是资源分配的基本单位，而线程是程序执行的基本单位。一个进程可以拥有多个线程，这些线程共享进程的资源（如内存、文件描述符等），从而能够高效地进行并发执行。

1.3 线程的生命周期

线程的生命周期包含了创建、运行、阻塞、终止等状态。线程的创建通常由操作系统或线程库提供的API进行，运行过程中可能会因为等待某些资源而进入阻塞状态，最终完成任务后退出。

二、C++中的线程编程

从C++11开始，C++标准库引入了<thread>库，使得C++程序能够直接支持线程的创建和管理。下面我们来看看如何使用C++进行基本的线程操作。

2.1 创建线程

在C++中，可以通过std::thread类来创建线程。下面是一个简单的例子：

```cpp

include

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

int main() { std::thread t(hello); // 创建一个新线程 t.join(); // 等待线程完成 return 0; } ```

在上述代码中，我们定义了一个名为hello的函数，并在主线程中创建了一个新线程来执行该函数。join方法的作用是等待线程执行完成。

2.2 线程参数

有时我们需要将参数传递给线程。可以通过构造std::thread时传递参数来实现：

```cpp

include

void printNum(int n) { std::cout << "Number: " << n << std::endl; }

int main() { std::thread t(printNum, 5); // 传递参数5给线程 t.join(); return 0; } ```

2.3 线程安全

在多线程编程中，线程安全是一个重要的概念。当多个线程同时访问共享资源时，如果没有适当的同步机制，可能会导致数据竞争和不可预测的行为。在C++中，我们可以使用std::mutex来实现互斥锁，从而确保同一时刻只有一个线程访问共享资源。

```cpp

include

std::mutex mtx; // 创建一个互斥锁 int sharedData = 0;

void increment() { for (int i = 0; i < 1000; ++i) { mtx.lock(); // 加锁 ++sharedData; // 修改共享数据 mtx.unlock(); // 解锁 } }

int main() { std::thread t1(increment); std::thread t2(increment); t1.join(); t2.join(); std::cout << "Final value: " << sharedData << std::endl; return 0; } ```

在以上代码中，我们使用mtx.lock()和mtx.unlock()来保护对sharedData的访问，确保在任意时刻只有一个线程能够进行修改。

三、C++中的条件变量

有时我们需要让线程在特定条件满足时才能继续执行。此时，条件变量（std::condition_variable）可以帮助我们实现线程之间的同步。

3.1 生产者-消费者模型

生产者-消费者问题是并发编程中的一个经典问题。在这个问题中，生产者生产数据并放入缓冲区，而消费者从缓冲区取出数据进行处理。下面是一个简单的示例：

```cpp

include

std::mutex mtx; // 互斥锁 std::condition_variable cv; // 条件变量 std::queue buffer; // 缓冲区 const unsigned int maxBufferSize = 10; // 最大缓冲区大小

void producer() { for (int i = 0; i < 20; ++i) { std::unique_lock lock(mtx); cv.wait(lock, { return buffer.size() < maxBufferSize; }); // 等待条件 buffer.push(i); // 生产数据 std::cout << "Produced: " << i << std::endl; cv.notify_all(); // 通知消费者 } }

void consumer() { for (int i = 0; i < 20; ++i) { std::unique_lock lock(mtx); cv.wait(lock, { return !buffer.empty(); }); // 等待条件 int value = buffer.front(); buffer.pop(); // 消费数据 std::cout << "Consumed: " << value << std::endl; cv.notify_all(); // 通知生产者 } }

int main() { std::thread t1(producer); std::thread t2(consumer); t1.join(); t2.join(); return 0; } ```

在这个例子中，生产者和消费者通过条件变量进行协调，确保在缓冲区满时生产者会等待，而在缓冲区空时消费者会等待。

四、C++并发编程的注意事项

4.1 死锁

死锁是指两个或多个线程在执行过程中因争夺资源而造成的一种互相等待的状态。避免死锁的方法有：

避免嵌套锁：尽量减少在同一线程中获取多个锁。
合理锁顺序：在多个线程中，遵循同样的锁获取顺序。
使用尝试锁：使用try_lock()等方式尝试获取锁，如果无法获取，可以进行适当处理。

4.2 数据竞争

数据竞争发生在多个线程同时访问共享数据并至少有一个线程在写的情况下。使用互斥锁或读写锁（std::shared_mutex）可以有效避免数据竞争。

4.3 线程泄漏

线程泄漏发生在创建线程后未能正确回收其资源，导致系统资源持续消耗。在使用std::thread时，确保所有线程在主线程结束前完成执行，或者在合适的地方调用join()或detach()方法。

五、C++并发编程的高级特性

自C++11以来，C++标准库还引入了许多并发编程的高级特性，如std::async、std::future和std::promise等。

5.1 std::async与std::future

std::async提供了一种简化的方式来执行异步操作，并返回一个std::future对象，通过该对象可以获取结果或者未来的异常。

```cpp

include

int calculateSum(int a, int b) { return a + b; }

int main() { std::future result = std::async(std::launch::async, calculateSum, 5, 10); std::cout << "Sum: " << result.get() << std::endl; // 阻塞等待结果 return 0; } ```

5.2 std::promise与std::future

std::promise和std::future一同使用可以实现线程之间的通信。std::promise用于设置值或异常，std::future用于获取这些值或异常。

```cpp

include

void setValue(std::promise & prom) { prom.set_value(42); // 设置值 }

int main() { std::promise prom; std::future fut = prom.get_future(); // 获取future std::thread t(setValue, std::ref(prom)); // 创建线程 std::cout << "Value: " << fut.get() << std::endl; // 获取值 t.join(); return 0; } ```