C++中如何使用并发编程？并发编程模型与实战技巧详解

C++从C++11标准开始正式引入并发编程支持，标准库提供了一套跨平台的并发工具，开发者无需依赖操作系统原生API就能实现多线程程序开发。这些工具覆盖了线程管理、同步机制、异步任务等核心场景，能够满足大部分并发编程需求。

C++并发编程核心组件

1. 线程管理：std::thread

std::thread是C++并发编程的基础类，用于创建和管理线程。创建线程时只需要传入可调用对象（函数、lambda表达式、函数对象等）和对应的参数即可。

#include <iostream>
#include <thread>
#include <chrono>

// 普通函数作为线程执行体
void print_task(int task_id) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "Task " << task_id << " executed by thread " << std::this_thread::get_id() << std::endl;
}

int main() {
    // 创建两个线程执行任务
    std::thread t1(print_task, 1);
    std::thread t2(print_task, 2);

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

    // 使用lambda表达式创建线程
    std::thread t3([](const std::string& msg) {
        std::cout << "Lambda thread: " << msg << std::endl;
    }, "Hello Concurrent World");
    t3.join();

    return 0;
}

需要注意，std::thread对象创建后必须调用join()等待线程结束，或者调用detach()让线程在后台运行，否则程序会抛出异常。如果线程被detach，后续不能再对其进行join操作。

2. 共享数据保护：互斥锁与锁管理

多个线程同时访问共享数据时会出现竞态条件，需要使用互斥锁std::mutex保证同一时间只有一个线程能访问共享资源。为了避免忘记释放锁导致死锁，通常配合std::lock_guard或std::unique_lock使用。

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

std::mutex g_mutex;
int g_counter = 0;

void increment_counter(int times) {
    for (int i = 0; i < times; ++i) {
        // 锁管理对象，构造时加锁，析构时自动释放锁
        std::lock_guard<std::mutex> lock(g_mutex);
        ++g_counter;
    }
}

int main() {
    std::vector<std::thread> threads;
    // 创建5个线程，每个线程累加1000次
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(increment_counter, 1000);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter value: " << g_counter << std::endl;
    return 0;
}

std::lock_guard适合简单的加锁场景，生命周期结束后自动释放锁；std::unique_lock更灵活，支持延迟加锁、手动释放锁、转移所有权等操作，适合需要复杂锁控制的场景。

3. 线程间通信：条件变量

条件变量std::condition_variable用于线程之间的同步通信，一个线程等待某个条件成立，另一个线程在条件成立时通知等待的线程。条件变量需要和互斥锁配合使用。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

std::mutex g_queue_mutex;
std::condition_variable g_cond;
std::queue<int> g_task_queue;
bool g_stop = false;

// 生产者线程
void producer() {
    for (int i = 0; i < 10; ++i) {
        std::lock_guard<std::mutex> lock(g_queue_mutex);
        g_task_queue.push(i);
        std::cout << "Produced task: " << i << std::endl;
        // 通知一个等待的消费者线程
        g_cond.notify_one();
    }
    // 生产完成后设置停止标志并通知所有消费者
    std::lock_guard<std::mutex> lock(g_queue_mutex);
    g_stop = true;
    g_cond.notify_all();
}

// 消费者线程
void consumer(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(g_queue_mutex);
        // 等待条件：队列不为空或者停止标志为true
        g_cond.wait(lock, []() {
            return !g_task_queue.empty() || g_stop;
        });

        if (g_stop && g_task_queue.empty()) {
            break;
        }

        int task = g_task_queue.front();
        g_task_queue.pop();
        lock.unlock(); // 处理任务时释放锁，避免阻塞其他线程

        std::cout << "Consumer " << id << " processed task: " << task << std::endl;
    }
}

int main() {
    std::thread prod(producer);
    std::thread cons1(consumer, 1);
    std::thread cons2(consumer, 2);

    prod.join();
    cons1.join();
    cons2.join();

    return 0;
}

使用条件变量的wait方法时，需要传入一个谓词函数，避免虚假唤醒导致程序逻辑错误。当条件不满足时，wait会自动释放锁并阻塞线程，被唤醒后会重新获取锁并检查条件。

4. 异步任务处理：std::async与std::future

如果不需要直接管理线程，只需要获取某个异步任务的执行结果，可以使用std::async启动异步任务，通过std::future获取任务的返回值。

#include <iostream>
#include <future>
#include <chrono>

// 模拟耗时计算任务
int calculate_sum(int a, int b) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return a + b;
}

int main() {
    // 启动异步任务，std::launch::async表示立即在新线程执行
    std::future<int> result_future = std::async(std::launch::async, calculate_sum, 10, 20);

    std::cout << "Doing other work while waiting for result..." << std::endl;
    // 获取异步任务结果，会阻塞直到任务完成
    int result = result_future.get();
    std::cout << "Async task result: " << result << std::endl;

    return 0;
}

std::async的启动策略有两种：std::launch::async保证任务在新线程执行，std::launch::deferred表示延迟执行，直到调用get()或wait()时才在当前线程执行。如果不指定策略，实现会自动选择。

并发编程常见注意事项

• 避免死锁：不要嵌套获取多个锁，如果必须获取多个锁，保证所有线程获取锁的顺序一致；也可以使用std::lock同时获取多个锁，避免死锁。
• 减少锁的持有时间：锁保护的代码范围尽量小，只保护共享数据的访问部分，避免将耗时操作放在锁内部。
• 优先使用标准库工具：尽量使用std::thread、std::mutex等标准库组件，避免直接使用操作系统原生API，保证代码的可移植性。
• 注意线程安全：标准库中大部分容器不是线程安全的，多线程访问时需要手动加锁保护，或者使用C++17引入的并行算法配合执行策略。

总结

C++并发编程的核心是利用标准库提供的线程、互斥锁、条件变量、异步任务等组件，合理设计并发模型。实际开发中需要根据场景选择合适的同步方式，平衡程序的执行效率和数据安全性，避免常见的并发问题。熟练掌握这些基础组件后，可以进一步学习无锁编程、线程池等高级并发技术，提升程序的并发性能。

C++并发编程std_thread互斥锁条件变量异步任务修改时间：2026-07-08 22:00:20