C++并发编程基础与实践一、引言随着多核处理器的普及，并发编程成为提升程序性能的关键技术。C++自C++11起，标准库

一、引言

随着多核处理器的普及，并发编程成为提升程序性能的关键技术。C++自C++11起，标准库正式支持多线程及并发编程，提供了丰富的线程管理和同步机制。

本文将系统介绍C++并发编程的基础概念、线程创建与管理、同步机制及实战应用，帮助你掌握现代C++并发开发技巧。

二、线程基础

1. 线程的概念

线程是进程中的执行单元，多线程允许同时执行多条指令流，提高CPU利用率。

2. C++11线程库

std::thread是C++11标准的线程类，用于创建和管理线程。

cpp复制编辑#include <thread>
#include <iostream>

void func() {
    std::cout << "线程执行中\n";
}

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

三、线程管理

1. 创建与启动线程

可传递参数与函数对象：

cpp复制编辑void printNum(int n) {
    std::cout << "数字: " << n << "\n";
}

std::thread t(printNum, 42);
t.join();

2. 线程分离

detach()使线程独立执行，主线程不等待。

cpp复制编辑t.detach();

注意：detach后线程生命周期由操作系统管理，须避免资源竞争。

四、线程同步

并发程序中，多线程访问共享资源需同步，避免数据竞争。

1. 互斥锁（mutex）

std::mutex用于保护临界区：

cpp复制编辑#include <mutex>

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

lock_guard自动加锁解锁，异常安全。

2. 读写锁（shared_mutex）

允许多个读者共享访问，写者独占。

3. 条件变量（condition_variable）

线程间等待和通知机制：

cpp复制编辑std::condition_variable cv;
std::mutex mtx;
bool ready = false;

void waitForReady() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });
    std::cout << "准备好了\n";
}

void setReady() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
}

五、原子操作

std::atomic支持无锁编程，保证单个变量操作的原子性。

cpp复制编辑#include <atomic>

std::atomic<int> atomicCounter(0);

void increment() {
    atomicCounter.fetch_add(1, std::memory_order_relaxed);
}

六、线程局部存储（Thread Local Storage）

每线程拥有独立变量实例，避免竞争。

cpp复制编辑thread_local int localVar = 0;

七、实战示例：多线程计算数组元素和

cpp复制编辑#include <iostream>
#include <vector>
#include <thread>

void partialSum(const std::vector<int>& data, size_t start, size_t end, int& result) {
    result = 0;
    for (size_t i = start; i < end; ++i) {
        result += data[i];
    }
}

int main() {
    std::vector<int> data(1000000, 1);

    int result1 = 0, result2 = 0;
    size_t mid = data.size() / 2;

    std::thread t1(partialSum, std::ref(data), 0, mid, std::ref(result1));
    std::thread t2(partialSum, std::ref(data), mid, data.size(), std::ref(result2));

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

    int total = result1 + result2;
    std::cout << "总和: " << total << "\n";

    return 0;
}