std::barrier 同步原语 ​

什么是 std::barrier ​

std::barrier 是 C++20 引入的可重用同步原语,定义在 <barrier> 头文件中。与一次性的 std::latch 不同,barrier 可以反复使用——每轮(phase)所有线程到达后,计数器自动重置,进入下一轮。barrier 还支持在每轮结束时执行一个完成回调函数。

cpp
#include <barrier>

// 3 个线程参与同步,每轮结束时打印提示
std::barrier sync_point(3, []() noexcept {
    std::cout << "--- 所有线程完成一轮 ---" << std::endl;
});

barrier 的成员函数 ​

函数说明
barrier(n, f)构造,n 为参与线程数,f 为每轮完成回调
arrive(n=1)到达并递减计数器,返回 arrival_token
wait(token)等待当前轮结束
arrive_and_wait()等价于 wait(arrive())
arrive_and_drop()到达并永久减少参与线程数
max()静态函数,返回支持的最大参与线程数

基本示例 ​

cpp
#include <iostream>
#include <thread>
#include <barrier>
#include <vector>
#include <mutex>
#include <string>
#include <chrono>
#include <functional>

std::mutex cout_mutex;

void safe_print(const std::string& msg) {
    std::lock_guard<std::mutex> lock(cout_mutex);
    std::cout << msg << std::endl;
}

// ============================
// 示例1:基本的多轮同步
// ============================

void basic_demo() {
    constexpr int num_threads = 3;
    constexpr int num_rounds = 3;

    // 每轮结束时执行的回调
    auto on_phase_complete = []() noexcept {
        safe_print("  >>> 所有线程完成一轮 <<<");
    };

    std::barrier sync_point(num_threads, on_phase_complete);

    std::vector<std::jthread> threads;
    for (int i = 0; i < num_threads; i++) {
        threads.emplace_back([&sync_point, i, num_rounds] {
            for (int round = 0; round < num_rounds; round++) {
                // 模拟工作
                std::this_thread::sleep_for(
                    std::chrono::milliseconds(20 * (i + 1)));
                safe_print("  线程 " + std::to_string(i)
                    + " 完成第 " + std::to_string(round + 1) + " 轮");

                // 到达并等待所有线程
                sync_point.arrive_and_wait();
            }
        });
    }
}

// ============================
// 示例2:分阶段数据处理
// ============================

void pipeline_demo() {
    constexpr int num_threads = 4;
    std::vector<int> data(num_threads, 0);

    int phase_counter = 0;
    auto on_complete = [&]() noexcept {
        phase_counter++;
        // 在每轮完成后汇总(只有最后到达的线程执行这个回调)
        int sum = 0;
        for (int v : data) sum += v;
        safe_print("  阶段 " + std::to_string(phase_counter)
            + " 完成,数据总和: " + std::to_string(sum));
    };

    std::barrier sync(num_threads, on_complete);

    std::vector<std::jthread> threads;
    for (int i = 0; i < num_threads; i++) {
        threads.emplace_back([&sync, &data, i] {
            // 阶段1:初始化数据
            data[i] = i + 1;
            sync.arrive_and_wait();

            // 阶段2:数据翻倍
            data[i] *= 2;
            sync.arrive_and_wait();

            // 阶段3:数据加10
            data[i] += 10;
            sync.arrive_and_wait();
        });
    }
}

// ============================
// 示例3:arrive 和 wait 分离
// ============================

void separate_arrive_wait_demo() {
    constexpr int num_threads = 3;

    std::barrier sync(num_threads);

    std::vector<std::jthread> threads;
    for (int i = 0; i < num_threads; i++) {
        threads.emplace_back([&sync, i] {
            safe_print("  线程 " + std::to_string(i) + " 开始工作");

            // arrive() 返回 arrival_token,不阻塞
            auto token = sync.arrive();

            // 到达后可以做一些不依赖其他线程的工作
            safe_print("  线程 " + std::to_string(i) + " 做独立工作");

            // 需要同步时才 wait
            sync.wait(std::move(token));

            safe_print("  线程 " + std::to_string(i) + " 同步完成");
        });
    }
}

// ============================
// 示例4:arrive_and_drop——线程退出
// ============================

void drop_demo() {
    constexpr int num_threads = 4;
    constexpr int num_rounds = 3;

    int round_count = 0;
    auto on_complete = [&]() noexcept {
        round_count++;
        safe_print("  >>> 第 " + std::to_string(round_count) + " 轮完成 <<<");
    };

    std::barrier sync(num_threads, on_complete);

    std::vector<std::jthread> threads;
    for (int i = 0; i < num_threads; i++) {
        threads.emplace_back([&sync, i, num_rounds] {
            for (int round = 0; round < num_rounds; round++) {
                safe_print("  线程 " + std::to_string(i)
                    + " 第 " + std::to_string(round + 1) + " 轮");

                // 线程0在第2轮后退出
                if (i == 0 && round == 1) {
                    safe_print("  线程 0 退出同步(arrive_and_drop)");
                    sync.arrive_and_drop();  // 永久减少参与者数量
                    return;
                }

                sync.arrive_and_wait();
            }
        });
    }
}

// ============================
// 示例5:模拟迭代计算(雅可比迭代)
// ============================

void iterative_computation_demo() {
    // 模拟简单的并行迭代计算
    constexpr int size = 8;
    constexpr int iterations = 3;
    constexpr int num_threads = 2;

    std::vector<double> current(size, 1.0);
    std::vector<double> next(size, 0.0);

    auto on_iteration_done = [&]() noexcept {
        // 每轮结束后交换 current 和 next
        std::swap(current, next);
    };

    std::barrier sync(num_threads, on_iteration_done);

    std::vector<std::jthread> threads;
    int chunk_size = size / num_threads;

    for (int t = 0; t < num_threads; t++) {
        int start = t * chunk_size;
        int end = (t == num_threads - 1) ? size : start + chunk_size;

        threads.emplace_back([&, start, end] {
            for (int iter = 0; iter < iterations; iter++) {
                // 每个线程处理自己的数据块
                for (int i = start; i < end; i++) {
                    next[i] = current[i] * 0.5 + 0.25;
                }
                // 等待所有线程完成本轮计算
                sync.arrive_and_wait();
            }
        });
    }

    // 等待所有线程完成(jthread 析构自动 join)
    threads.clear();

    safe_print("最终结果:");
    for (int i = 0; i < size; i++) {
        safe_print("  data[" + std::to_string(i) + "] = "
            + std::to_string(current[i]));
    }
}

// ============================
// 示例6:无完成回调的 barrier
// ============================

void no_callback_demo() {
    constexpr int num_threads = 3;

    // 不提供完成回调——使用默认的空操作
    std::barrier sync(num_threads);

    std::vector<std::jthread> threads;
    for (int i = 0; i < num_threads; i++) {
        threads.emplace_back([&sync, i] {
            safe_print("  线程 " + std::to_string(i) + " 第一阶段");
            sync.arrive_and_wait();

            safe_print("  线程 " + std::to_string(i) + " 第二阶段");
            sync.arrive_and_wait();
        });
    }
}

int main() {
    std::cout << "=== 基本多轮同步 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 分阶段处理 ===" << std::endl;
    pipeline_demo();

    std::cout << "\n=== arrive/wait 分离 ===" << std::endl;
    separate_arrive_wait_demo();

    std::cout << "\n=== arrive_and_drop ===" << std::endl;
    drop_demo();

    std::cout << "\n=== 迭代计算 ===" << std::endl;
    iterative_computation_demo();

    std::cout << "\n=== 无回调 ===" << std::endl;
    no_callback_demo();

    return 0;
}

barrier vs latch ​

特性std::barrierstd::latch
可重用可以(多轮)不可以(一次性)
完成回调支持不支持
参与者退出arrive_and_drop不支持
计数器重置每轮自动重置不重置
适用场景多轮迭代同步一次性等待
arrive/wait 分离支持支持

barrier 的工作流程 ​

初始化: expected = N(参与线程数)

每轮(phase):
  1. 线程调用 arrive() 或 arrive_and_wait()
  2. 计数器递减
  3. 当计数器归零:
     a. 执行完成回调 completion()
     b. 计数器重置为 expected
     c. 释放所有等待的线程
  4. 进入下一轮

适用场景 ​

  • 并行迭代计算(雅可比迭代、矩阵运算)
  • 分阶段的数据处理管道
  • 多轮同步的工作线程池
  • 游戏引擎的帧同步
  • 需要在同步点执行汇总操作的场景

常见问题 ​

完成回调在哪个线程执行?

在最后一个到达的线程中同步执行。执行期间其他线程保持等待。

完成回调有什么限制?

回调必须是 noexcept 的(不能抛出异常),并且必须满足 MoveConstructible 和 Destructible 要求。

arrive_and_drop 之后会怎样?

调用线程不再参与后续轮次,barrier 的 expected 计数永久减 1。后续轮次只需要剩余线程到达即可完成。

arrive() 返回的 token 可以在不同轮次使用吗?

不可以。arrival_token 只能用于当前轮或紧接着的下一轮的 wait()。

注意事项 ​

  • barrier 不能复制或移动
  • 完成回调必须是 noexcept 的
  • arrive_and_drop 永久减少参与者——不能撤销
  • 不要在完成回调中调用 barrier 自身的成员函数
  • arrival_token 不能跨轮次使用
  • expected 为 0 时构造 barrier 是合法的,但没有线程能到达

总结 ​

std::barrier 是 C++20 引入的可重用多轮同步原语。与一次性的 std::latch 不同,barrier 每轮所有线程到达后自动重置计数器,进入下一轮。它支持完成回调——在每轮结束时由最后到达的线程执行,适合汇总数据或交换缓冲区。arrive_and_drop 允许线程永久退出同步,减少后续轮次的参与者数量。barrier 适用于并行迭代计算、分阶段处理管道、帧同步等需要多轮同步的场景。