C++ STL 之 latch / barrier / semaphore 详解（C++20 并发新原语）

Ricky_Theseus

313人浏览 · 2026-06-28 09:03:33

Ricky_Theseus · 2026-06-28 09:03:33 发布

C++ STL 之 latch / barrier / semaphore 详解（C++20 并发新原语）

一、为什么需要新的并发原语

C++11 提供了 std::thread、std::mutex、std::condition_variable 和 std::future，但这些工具在面对"等待一组任务完成"、"限制并发数量"等常见场景时，要么需要手写复杂的同步逻辑，要么性能不够理想。C++20 从 POSIX 和 Java 等生态引入了三个标准库同步原语：

原语	作用	是否可复用
`std::latch`	一次性同步点，N 个线程到达后放行	否
`std::barrier`	可复用同步点，每轮到达触发回调	是
`std::counting_semaphore`	计数信号量，控制资源访问数	是

它们都定义在 <latch>、<barrier>、<semaphore> 头文件中，底层通常基于原子操作或 futex 实现，比条件变量方案更轻量。

二、latch——一次性栅栏

std::latch 是一个向下计数的一次性屏障。构造时指定初始计数，线程调用 count_down() 减少计数，调用 wait() 阻塞直到计数归零。计数到达零后永久保持，不可重置。

#include <latch>
#include <thread>
#include <vector>
#include <iostream>

void demo_latch() {
    std::latch done{3};  // 等待 3 个任务

    std::vector<std::jthread> workers;
    for (int i = 0; i < 3; ++i) {
        workers.emplace_back([&, i] {
            // 模拟工作
            std::this_thread::sleep_for(std::chrono::milliseconds(100 * i));
            std::cout << "worker " << i << " done\n";
            done.count_down();  // 计数减 1
        });
    }

    done.wait();  // 等待所有 3 个 worker
    std::cout << "all workers done, proceed\n";
}

关键 API：

count_down(n = 1) —— 计数减 n，不阻塞
wait() —— 阻塞直到计数为 0
arrive_and_wait(n = 1) —— 等价于 count_down(n) + wait()
try_wait() —— 非阻塞检查计数是否为 0

典型场景：初始化加载、多路并行计算后合并结果、所有线程就绪后同时开始。

三、barrier——可复用栅栏

std::barrier 是 latch 的升级版。它像一个"回合制"同步点：每轮 N 个线程全部到达后，一起放行，然后自动进入下一轮。每轮结束时还会执行一个完成回调（completion function）。

#include <barrier>
#include <thread>
#include <iostream>

void demo_barrier() {
    constexpr int N = 3;
    int round = 0;
    std::barrier sync{N, [&]() noexcept {
        std::cout << "=== round " << ++round << " done ===\n";
    }};

    std::vector<std::jthread> workers;
    for (int i = 0; i < N; ++i) {
        workers.emplace_back([&, i] {
            for (int r = 0; r < 3; ++r) {
                std::this_thread::sleep_for(std::chrono::milliseconds(50 * i));
                std::cout << "worker " << i << " arrives at round " << r << "\n";
                sync.arrive_and_wait();  // 到达并等待本轮所有人
            }
        });
    }
}

每次 arrive_and_wait() 返回时，所有线程都位于同一轮次的同一时间点——这就是 barrier 的核心保证。

关键 API 与 latch 的差异：

arrive(n = 1) —— 到达，返回 std::barrier::arrival_token（用于 wait() 分离）
arrive_and_wait() —— 到达并等待
arrive_and_drop() —— 永久减少本轮参与线程数（退出专用）

典型场景：迭代计算中每轮结束后同步、游戏帧循环中的多线程阶段同步、流水线作业中所有阶段对齐。

四、semaphore——计数信号量

std::counting_semaphore<LeastMaxValue> 是一个计数信号量，模板参数 LeastMaxValue 指定最大计数的下限。std::binary_semaphore 是其特化 counting_semaphore<1>。

#include <semaphore>
#include <thread>
#include <queue>
#include <iostream>

std::counting_semaphore<10> sem{3};   // 最多 3 个并发
std::mutex mtx;
std::queue<int> q;

void producer() {
    for (int i = 0; i < 10; ++i) {
        sem.acquire();                 // P 操作：计数减 1，满则阻塞
        {
            std::lock_guard lk{mtx};
            q.push(i);
            std::cout << "produce " << i << "\n";
        }
    }
}

void consumer() {
    for (int i = 0; i < 10; ++i) {
        int val;
        {
            std::lock_guard lk{mtx};
            if (!q.empty()) {
                val = q.front();
                q.pop();
            }
        }
        sem.release();                 // V 操作：计数加 1，唤醒等待者
        std::cout << "consume " << val << "\n";
    }
}

关键 API：

acquire() —— P 操作，计数减 1，不足时阻塞
release(n = 1) —— V 操作，计数加 n，唤醒等待者
try_acquire() —— 非阻塞版 acquire，失败返回 false
try_acquire_for(dur) —— 带超时的 acquire

典型场景：线程池任务队列限流、连接池资源分配、生产者-消费者协调。

五、与 C++11 条件变量方案对比

5.1 latch vs. condition_variable

用条件变量实现"等待 N 个线程完成"：

// C++11 方式
int count = 3;
std::mutex mtx;
std::condition_variable cv;
{
    std::unique_lock lk{mtx};
    if (--count == 0)
        cv.notify_all();
    else
        cv.wait(lk, [&]{ return count == 0; });
}

问题：

需要额外 mutex 和 int 计数器
虚假唤醒（spurious wakeup）必须用谓词循环检查
notify_all() 唤醒所有等待者，即使计数没到零

用 std::latch：

std::latch done{3};
done.count_down();     // 任何线程
done.wait();           // 等待线程

零额外变量，零虚假唤醒
底层通常基于 std::atomic<int> + futex，无锁路径

5.2 barrier vs. 手写循环

手写可复用栅栏需要条件变量 + 计数器 + 轮次标志，逻辑极易出错。std::barrier 封装了全部状态机，且完成回调的执行保证：恰好有一个线程执行回调，其他线程在回调完成后才被放行。

5.3 semaphore vs. condition_variable

维度	`condition_variable`	`counting_semaphore`
状态	无状态，需外部变量	自带计数状态
虚假唤醒	可能发生，需谓词检查	不产生
多资源管理	需自行计算	acquire/release 原生支持
超时	支持 wait_for/until	同上