搞懂互斥、同步与异步：C++并发编程

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

int shared_counter = 0;          // 共享资源
std::mutex mtx;                  // 定义一把互斥锁

// 不加锁的危险操作
void unsafe_increment() {
    for (int i = 0; i < 10000; ++i) {
        shared_counter++;        // 看似一行代码，实际包含“读-改-写”三步，极易发生竞态条件
    }
}

// 加锁的安全操作
void safe_increment() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 构造时自动加锁，离开作用域自动解锁（RAII机制）
        shared_counter++;        // 临界区代码，此时只有一个线程能执行
    }
}

int main() {
    std::vector<std::thread> threads;
    
    // 启动 10 个线程进行累加
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(safe_increment); // 尝试替换为 unsafe_increment 看看结果
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    // 期望结果：100000。如果不加锁，结果通常会小于这个值且每次运行不一致
    std::cout << "最终计数结果: " << shared_counter << std::endl;
    return 0;
}

加锁的安全操作：safe_increment()

不加锁的危险操作：

二、同步（Synchronization）：按部就班的“协调员”

核心定义：同步是指多个线程在协作时，需要按照预定的先后次序有序地运行。一个线程的执行依赖于另一个线程发出的信号或产生的结果。

生活类比：就像工厂的流水线。A工序（比如组装零件）必须完成后，B工序（比如喷漆）才能开始。B工序必须“同步等待”A工序的完成信号。

实战示例：

在 C++ 中，std::condition_variable（条件变量）是实现线程同步的神器，常用于“生产者-消费者”模型中的等待与唤醒：

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

std::queue<int> data_queue;
std::mutex mtx;
std::condition_variable cv;
const int MAX_SIZE = 5;

// 消费者线程
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 同步等待：当队列为空时，释放锁并阻塞等待，直到被生产者唤醒
        cv.wait(lock, []{ return !data_queue.empty(); });
        
        int data = data_queue.front();
        data_queue.pop();
        std::cout << "消费者处理了数据: " << data << std::endl;
        lock.unlock(); // 处理数据时尽量释放锁，提高并发度
    }
}

// 生产者线程
void producer() {
    for (int i = 1; i <= 5; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟耗时
        {
            std::lock_guard<std::mutex> lock(mtx);
            data_queue.push(i);
            std::cout << "生产者产生了数据: " << i << std::endl;
        }
        cv.notify_one(); // 唤醒一个正在等待的消费者线程（同步信号）
    }
}

int main() {
    std::thread t_pro(producer);
    std::thread t_con(consumer);
    t_pro.join();
    t_con.join();
    return 0;
}

三、异步（Asynchronous）：甩手不管的“大掌柜”

核心定义：异步是指发起一个操作后，不需要等待它完成，调用者可以立即返回去处理其他事情，等操作完成后通过回调、事件或状态查询来获取结果。

生活类比：这就好比点外卖。你下单后不需要站在店门口等厨师做完，而是可以继续刷剧或工作。等外卖做好了，骑手会通过电话（回调/通知）告诉你去取餐。

实战示例：

C++11 引入了 std::async 和 std::future，让我们能非常优雅地实现异步编程：

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

// 模拟一个耗时的计算任务
int heavy_task(int seconds) {
    std::cout << "异步任务开始执行，需要耗时 " << seconds << " 秒..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(seconds));
    return 42; // 返回计算结果
}

int main() {
    std::cout << "主线程：发起异步任务..." << std::endl;
    
    // std::async 启动一个异步任务，std::launch::async 确保在新线程中执行
    std::future<int> result = std::async(std::launch::async, heavy_task, 3);
    
    std::cout << "主线程：任务已发起，我先去忙别的（不阻塞）..." << std::endl;
    // 这里主线程可以做其他事情，比如处理UI响应、接受新请求等
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "主线程：我忙完了，现在看看任务结果好了没..." << std::endl;
    
    // get() 会阻塞等待，直到异步任务完成并返回结果
    int final_result = result.get();
    std::cout << "主线程：拿到异步任务的结果了 -> " << final_result << std::endl;
    
    return 0;
}

四、综合实战：生产者-消费者模型

在实际开发中，这三个概念往往是交织在一起的。最经典的例子就是“生产者-消费者”模型：我们需要互斥来保护共享的缓冲区队列，同时需要同步来协调生产者和消费者的速度（满了等、空了等），而整个数据的流转过程往往又是异步的。

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

std::queue<int> buffer;
std::mutex mtx;
std::condition_variable cv;
const int MAX_BUFFER_SIZE = 5;
bool production_done = false; // 生产结束标志

void producer() {
    for (int i = 1; i <= 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        // 同步：缓冲区满时，等待消费者取走数据
        cv.wait(lock, []{ return buffer.size() < MAX_BUFFER_SIZE; });
        
        buffer.push(i);
        std::cout << "[互斥保护] 生产者放入数据: " << i << std::endl;
        
        lock.unlock();
        cv.notify_all(); // 唤醒消费者
        std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 模拟生产耗时
    }
    
    // 生产结束，通知消费者退出
    {
        std::lock_guard<std::mutex> lock(mtx);
        production_done = true;
    }
    cv.notify_all();
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 同步：缓冲区空且生产未结束时，等待生产者放入数据
        cv.wait(lock, []{ return !buffer.empty() || production_done; });
        
        if (buffer.empty() && production_done) break;
        
        int data = buffer.front();
        buffer.pop();
        std::cout << "[互斥保护] 消费者取出数据: " << data << std::endl;
        
        lock.unlock();
        cv.notify_all(); // 唤醒生产者
        std::this_thread::sleep_for(std::chrono::milliseconds(300)); // 模拟消费耗时
    }
}

int main() {
    std::thread t_pro(producer);
    std::thread t_con(consumer);
    t_pro.join();
    t_con.join();
    return 0;
}

五、常见误区排雷

在学习这三个概念时，很多初学者容易掉进一些思维陷阱，这里帮大家梳理一下：

同步 ≠ 阻塞：同步强调的是“有序协作”或“等待结果”。虽然同步 I/O 通常是阻塞的，但在多线程环境下，同步任务完全可以在不同的线程中并行推进，只是逻辑上存在先后依赖。

异步 ≠ 并发：异步是一种编程模型，强调的是“发起后不等待”。单线程也可以实现异步（比如 JavaScript 的事件循环机制），它通过回调来避免阻塞，并不一定需要开启多个线程来实现并发。

互斥只是同步的一种特殊形式：互斥关注的是“独占资源”，防止冲突；而同步的范围更广，它关注的是“协作顺序”。互斥可以看作是一种特殊的同步，即强制所有线程在访问临界区时串行化。

六、总结

为了帮你更好地记忆，我们把这三个概念浓缩成一张表：

概念	核心作用	C++ 常用工具	一句话记忆口诀
互斥	保护共享资源，防止数据竞争	`std::mutex`, `std::lock_guard`	厕所要上锁，一次进一个
同步	协调执行顺序，确保依赖满足	`std::condition_variable`, `std::future`	产线讲顺序，等完再开工
异步	提高响应速度，避免无效等待	`std::async`, `std::future`	外卖不用等，到了电话叫

AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

项目介绍基于java+vue的十字路口协同通行信号优化系统设计与实现（含模型描述及部分示例代码）专栏近期有大量优惠还请多多点一下关注加油谢谢你的鼓励是我前行的动力谢谢支持加油谢谢

AtomGit开源社区

基于模型预测控制的波浪能转换器（WEC）研究（Matlab代码实现）

本文模拟从波浪能转换器（WEC）中提取的能量，当受控移动窗口阻塞 MPC 时，单设备。它还比较了使用标准MPC和GPC控制时WEC提取的能量。摘要：海浪能是可再生能源最集中的来源之一。然而，到目前为止，它还没有达到商业化所需的经济可行性。为了提高波浪能转换器的效率，已经提出了几种先进的控制策略，包括模型预测控制（MPC）。然而，每个优化问题的计算负担都是传统（全自由度）MPC的缺点，这通常会