std::latch 同步原语 ​

什么是 std::latch ​

std::latch 是 C++20 引入的一次性倒计数同步原语,定义在 <latch> 头文件中。它维护一个内部计数器,线程可以递减计数器并等待计数器归零。一旦计数器到达零,所有等待的线程被释放,latch 不能重置或重用。

latch 常用于"等待所有线程完成某个阶段"的场景——比如等待所有工作线程初始化完毕,或者等待所有数据加载完成。

cpp
#include <latch>

std::latch done(3);  // 计数器初始化为 3
// 每个线程完成工作后调用 done.count_down()
// 主线程调用 done.wait() 等待计数器归零

latch 的成员函数 ​

函数说明
latch(n)构造,计数器初始化为 n
count_down(n=1)原子地将计数器减 n(不阻塞)
try_wait()检查计数器是否为零(不阻塞)
wait()阻塞直到计数器为零
arrive_and_wait(n=1)等价于 count_down(n) + wait()
max()静态函数,返回计数器支持的最大值

基本示例 ​

cpp
#include <iostream>
#include <thread>
#include <latch>
#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_workers = 5;
    std::latch work_done(num_workers);

    std::vector<std::jthread> workers;
    for (int i = 0; i < num_workers; i++) {
        workers.emplace_back([&work_done, i] {
            // 模拟不同时长的工作
            std::this_thread::sleep_for(std::chrono::milliseconds(50 * (i + 1)));
            safe_print("  工作线程 " + std::to_string(i) + " 完成");
            work_done.count_down();  // 完成后递减计数器
        });
    }

    // 主线程等待所有工作完成
    work_done.wait();
    safe_print("所有工作线程已完成");
}

// ============================
// 示例2:Boss-Worker 模式
// ============================

void boss_worker_demo() {
    constexpr int num_workers = 4;

    // 两个 latch:一个让 boss 等工人完成,一个让工人等 boss 发令
    std::latch ready(num_workers);  // 工人准备就绪
    std::latch go(1);               // boss 发出开始信号

    std::vector<std::jthread> workers;
    for (int i = 0; i < num_workers; i++) {
        workers.emplace_back([&ready, &go, i] {
            // 准备阶段
            safe_print("  工人 " + std::to_string(i) + " 准备就绪");
            ready.count_down();  // 通知 boss 自己准备好了

            // 等待 boss 发令
            go.wait();

            // 开始工作
            safe_print("  工人 " + std::to_string(i) + " 开始工作");
        });
    }

    // Boss 等待所有工人准备就绪
    ready.wait();
    safe_print("Boss: 所有工人已准备就绪");

    // Boss 发出开始信号
    safe_print("Boss: 开始!");
    go.count_down();
}

// ============================
// 示例3:arrive_and_wait
// ============================

void arrive_and_wait_demo() {
    constexpr int num_threads = 4;
    std::latch sync_point(num_threads);

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

            // arrive_and_wait = count_down + wait
            // 递减计数器并等待所有线程到达
            sync_point.arrive_and_wait();

            // 所有线程都到达后才继续
            safe_print("  线程 " + std::to_string(i) + " 开始第二阶段");
        });
    }
}

// ============================
// 示例4:数据加载同步
// ============================

void data_loading_demo() {
    struct DataSource {
        std::string name;
        int load_time_ms;
    };

    std::vector<DataSource> sources = {
        {"数据库", 100},
        {"配置文件", 50},
        {"缓存", 30},
    };

    std::latch all_loaded(sources.size());
    std::vector<std::string> loaded_data(sources.size());

    std::vector<std::jthread> loaders;
    for (size_t i = 0; i < sources.size(); i++) {
        loaders.emplace_back([&, i] {
            // 模拟加载
            std::this_thread::sleep_for(
                std::chrono::milliseconds(sources[i].load_time_ms));
            loaded_data[i] = sources[i].name + " 已加载";
            safe_print("  " + sources[i].name + " 加载完成");
            all_loaded.count_down();
        });
    }

    // 等待所有数据源加载完成
    all_loaded.wait();
    safe_print("所有数据源加载完成,开始处理:");
    for (const auto& d : loaded_data) {
        safe_print("  " + d);
    }
}

// ============================
// 示例5:try_wait 非阻塞检查
// ============================

void try_wait_demo() {
    std::latch done(2);

    std::jthread t1([&done] {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        done.count_down();
    });

    std::jthread t2([&done] {
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        done.count_down();
    });

    // 非阻塞轮询
    while (!done.try_wait()) {
        safe_print("  还没完成,做其他事...");
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
    safe_print("全部完成");
}

// ============================
// 示例6:一次递减多个
// ============================

void multi_count_demo() {
    std::latch done(10);

    std::jthread t1([&done] {
        safe_print("  线程1: 完成 3 个任务");
        done.count_down(3);  // 一次递减 3
    });

    std::jthread t2([&done] {
        safe_print("  线程2: 完成 7 个任务");
        done.count_down(7);  // 一次递减 7
    });

    done.wait();
    safe_print("10 个任务全部完成");
}

int main() {
    std::cout << "=== 等待所有工作线程 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== Boss-Worker ===" << std::endl;
    boss_worker_demo();

    std::cout << "\n=== arrive_and_wait ===" << std::endl;
    arrive_and_wait_demo();

    std::cout << "\n=== 数据加载 ===" << std::endl;
    data_loading_demo();

    std::cout << "\n=== try_wait ===" << std::endl;
    try_wait_demo();

    std::cout << "\n=== 多计数 ===" << std::endl;
    multi_count_demo();

    return 0;
}

latch vs barrier vs condition_variable ​

特性std::latchstd::barriercondition_variable
可重用不可以(一次性)可以(可重复使用)可以
使用复杂度简单中等复杂(需要 mutex)
完成回调不支持支持不支持
计数器方向只能递减每轮自动重置需要手动管理
典型用途一次性等待所有线程多轮同步通用等待/通知

适用场景 ​

  • 等待多个线程完成初始化
  • 等待所有数据加载完毕后再处理
  • 多线程测试中同步所有线程同时开始
  • 一次性的"所有线程到达某个点"同步
  • 替代 condition_variable 的简单等待模式

常见问题 ​

latch 用完后可以重置吗?

不可以。latch 是一次性的。如果需要重复同步,使用 std::barrier。

count_down 的参数可以超过当前计数器值吗?

不可以。如果参数大于计数器当前值,行为是未定义的。

latch 比 condition_variable 好在哪里?

latch 不需要配合 mutex 使用,接口更简单,更不容易出错。对于"等待计数器归零"这个特定模式,latch 是最直接的工具。

latch 的所有操作都是线程安全的吗?

是的。count_down、wait、try_wait、arrive_and_wait 的并发调用不会产生数据竞争。

注意事项 ​

  • latch 是一次性的,计数器归零后不能重置
  • count_down 的参数不能超过计数器当前值
  • count_down 不阻塞,wait 阻塞
  • arrive_and_wait 等价于 count_down + wait
  • latch 不能被复制或移动
  • 析构 latch 时,不能有线程在 wait

总结 ​

std::latch 是 C++20 引入的一次性倒计数同步原语,用于等待一组线程到达某个同步点。它比 condition_variable + mutex 的组合更简单直接——只需要初始化计数器,每个线程完成后 count_down,等待方调用 wait。latch 的所有操作都是线程安全的。它适合"等待所有线程完成某件事"的一次性场景,如初始化同步、数据加载同步等。如果需要多轮重复同步,应该使用 std::barrier。