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

本文链接：https://blog.youkuaiyun.com/2401_90032281/article/details/145019507

C++语言的并发编程

引言

随着计算机技术的飞速发展，尤其是多核处理器的普及，如何高效地利用计算机资源成为了一个重要话题。在这个背景下，并发编程已经成为了一种必须掌握的技能。C++作为一种强大的编程语言，也提供了丰富的工具和库来支持并发编程。本文将详细探讨C++中的并发编程概念、技术及实例，以帮助读者更深入地理解这一领域。

并发编程的基础概念

1. 什么是并发？

并发指的是多个进程或线程在同一时间段内执行，可以是交错执行或真正的同时执行。与串行执行相对，并发能够提高程序的执行效率，更好地利用多核处理器的资源。

2. 线程与进程的区别

进程是操作系统中的一个基本执行单元，拥有独立的地址空间和资源。
线程是进程中的一个执行路径，同一进程中的多个线程可以共享进程的资源（如内存），但每个线程有自己的执行栈和程序计数器。

3. 并行与并发

并发是一种概念，是指程序在逻辑上能够同时执行多个任务，而并行是物理上的执行，指在多个处理器上同时执行多个任务。并发不一定意味着并行，但并行必然包含并发。

C++中的并发编程

C++从C++11标准开始，正式引入了对并发编程的支持。新标准提供了线程库、原子操作、条件变量等功能，极大地丰富了并发编程的工具。

1. 线程的创建与管理

在C++11中，std::thread类用于创建和管理线程。我们可以通过传递函数指针、函数对象或 lambda 表达式来启动新线程。

示例：

```cpp

include

void threadFunction(int id) { std::cout << "线程 " << id << " 正在运行" << std::endl; }

int main() { std::thread t1(threadFunction, 1); std::thread t2(threadFunction, 2);

t1.join(); // 等待线程t1完成
t2.join(); // 等待线程t2完成

return 0;

} ```

在这个例子中，我们创建了两个线程并分别执行threadFunction函数。调用join方法可以等待线程完成。

2. 互斥量与数据保护

在并发编程中，多个线程往往会访问共享数据，这时候就需要对共享数据进行保护，以避免数据竞争。C++提供了std::mutex类来实现互斥锁。

示例：

```cpp

include

std::mutex mtx; int counter = 0;

void increment(int id) { for (int i = 0; i < 10000; ++i) { mtx.lock(); // 锁定互斥量 ++counter; mtx.unlock(); // 解锁互斥量 } }

int main() { std::thread t1(increment, 1); std::thread t2(increment, 2);

t1.join();
t2.join();

std::cout << "最终计数器值: " << counter << std::endl; // 保证数据安全性
return 0;

} ```

在这个示例中，我们使用std::mutex来保护counter变量，确保在任何时刻只有一个线程可以修改它。

3. 条件变量

条件变量用于在线程之间进行通知。C++通过std::condition_variable提供了条件变量的实现，它能够使线程以某种条件等待。

示例：

```cpp

include

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

void worker() { std::unique_lock lock(mtx); while (!ready) cv.wait(lock); // 等待条件变量

std::cout << "工作线程开始工作" << std::endl;

}

int main() { std::thread t(worker);

{
    std::lock_guard<std::mutex> lock(mtx);
    ready = true; // 改变状态
}

cv.notify_one(); // 通知等待的线程
t.join();

return 0;

} ```

在这个例子中，worker线程在条件变量上等待。当主线程改变ready状态并调用notify_one时，worker线程被唤醒，开始执行任务。

4. 原子操作

C++11提供了原子类型（std::atomic），用于在多个线程中安全地操作共享变量。原子操作确保了在多个线程同时操作变量时的安全性，并且不需要使用锁。

示例：

```cpp

include

std::atomic counter(0);

void increment() { for (int i = 0; i < 10000; ++i) { ++counter; // 原子操作，线程安全 } }

int main() { std::thread t1(increment); std::thread t2(increment);

t1.join();
t2.join();

std::cout << "最终计数器值: " << counter.load() << std::endl; // 获取原子变量值
return 0;

} ```

这里，使用std::atomic<int>来定义一个原子计数器，在多个线程中安全地进行自增操作，而无需额外的锁定机制。

5. 线程的管理与异常处理

在C++中，手动管理线程的生命周期是必要的，尤其是确保每个线程在程序结束前完成。使用std::terminate处理未完成的线程，以防止程序异常结束。

示例：

```cpp

include

void mayThrow() { throw std::runtime_error("线程抛出异常"); }

int main() { std::thread t(mayThrow);

try {
    t.join(); // 等待线程结束
} catch (const std::exception& e) {
    std::cerr << "捕获到异常: " << e.what() << std::endl;
    // 在此处理异常
}

return 0;

} ```

在上例中，我们创建了一个可能抛出异常的线程，并在主线程中捕获这个异常。这表明我们需要在多线程环境中谨慎处理异常。

高级特性

1. 任务与线程池

C++标准库并未直接提供线程池的实现，但我们可以使用std::async来提交任务。这个功能使得我们能够以更加直观的方式处理并发任务。

示例：

```cpp

include

int doWork() { // 模拟耗时操作 return 42; }

int main() { std::future result = std::async(std::launch::async, doWork);

// 在此可以做其他事情
std::cout << "Doing some other work..." << std::endl;

// 获取结果
std::cout << "Result: " << result.get() << std::endl;

return 0;

} ```

在这个示例中，我们使用std::async启动一个异步任务，返回一个std::future对象，通过该对象我们可以获取任务的结果。

2. 并发容器

C++标准库中的并发容器尚不完善，然而，可以使用如Intel的TBB（Threading Building Blocks）等库提供的并发容器。它们能够更好地管理并发任务和数据容器，避免手动管理锁的问题。

结语

C++中的并发编程为我们提供了强大的工具来创建高效且响应迅速的应用程序。通过合理使用线程、互斥量、条件变量和原子操作，我们可以在保证数据安全性的同时，有效提升程序的性能。虽然并发编程带来了难度和挑战，但也是提升程序执行效率的关键。希望本文能够帮助读者更好地理解C++中的并发编程，开创出更高效的编程实践。