屏障与栅栏：让线程们“对齐”再出发

各位好，今天我们来聊聊多线程编程里一个挺有意思的同步工具——屏障（Barrier）。

你想想看，有时候我们有一堆线程在干活，但希望它们都干到某个“里程碑”时，统一停下来等一等，等所有线程都到了，再一起往下走。这不就是“对齐”吗？

我早年做图像处理时，就遇到过这种场景：多个线程分别处理图像的不同分块，处理完后需要合并结果。如果某个线程跑得太快，直接去读还没处理完的分块，那数据就全乱了。嗯，这时候屏障就派上用场了。

屏障到底是什么？

说白了，屏障就是一个“集合点”。

每个线程到达屏障后，都会阻塞等待，直到所有参与线程都到达，然后屏障“放行”，所有线程继续执行后续代码。

这和互斥锁、条件变量不太一样。锁是保护共享资源的，屏障是协调进度的。你可以把它想象成跑步比赛——所有选手都到起跑线了，发令枪才响。

pthread_barrier_t 怎么用？

POSIX 线程库提供了 pthread_barrier_t 类型，配合两个主要函数：

• pthread_barrier_init() —— 初始化屏障，指定参与线程数
• pthread_barrier_wait() —— 线程到达屏障，等待
• pthread_barrier_destroy() —— 销毁屏障

来看一个典型的分治计算例子：

#include <pthread.h>
#include <stdio.h>

#define NUM_THREADS 4
#define TOTAL_WORK 1000

pthread_barrier_t barrier;
int shared_data[TOTAL_WORK];
int partial_sums[NUM_THREADS];

void* worker(void* arg) {
    int id = *(int*)arg;
    int chunk = TOTAL_WORK / NUM_THREADS;
    int start = id * chunk;
    int end = (id == NUM_THREADS - 1) ? TOTAL_WORK : start + chunk;

    // 阶段1：计算局部和
    int sum = 0;
    for (int i = start; i < end; i++) {
        sum += shared_data[i];
    }
    partial_sums[id] = sum;

    // 所有线程在这里等待，确保局部和都算完了
    pthread_barrier_wait(&barrier);

    // 阶段2：只有线程0做全局汇总
    if (id == 0) {
        int total = 0;
        for (int i = 0; i < NUM_THREADS; i++) {
            total += partial_sums[i];
        }
        printf("全局总和 = %d\n", total);
    }

    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    int ids[NUM_THREADS];

    // 初始化屏障，计数为4
    pthread_barrier_init(&barrier, NULL, NUM_THREADS);

    // 初始化数据
    for (int i = 0; i < TOTAL_WORK; i++) {
        shared_data[i] = i + 1;
    }

    // 创建线程
    for (int i = 0; i < NUM_THREADS; i++) {
        ids[i] = i;
        pthread_create(&threads[i], NULL, worker, &ids[i]);
    }

    // 等待线程结束
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_barrier_destroy(&barrier);
    return 0;
}

这段代码里，每个线程先算自己的局部和，然后调用 pthread_barrier_wait()。当四个线程都到达屏障后，屏障打开，线程0负责汇总。如果没有屏障，线程0可能在其他线程还没算完时就去读 partial_sums，结果可想而知。

屏障的“一次性”与“重用”

屏障初始化后，可以反复使用。每次所有线程到达后，屏障自动重置，等待下一轮。这在循环计算中特别有用。

举个例子，迭代求解方程组时，每轮迭代都需要所有线程同步一次。屏障正好满足这个需求。

不过要注意：pthread_barrier_wait() 返回后，屏障的计数会重置。如果你需要不同的同步点，就得用多个屏障。

避坑指南：我踩过的几个雷

我曾经在项目里犯过一个低级错误：初始化屏障时，把参与线程数写成了 NUM_THREADS + 1，结果有一个线程永远等不到，程序直接死锁。排查了半天才发现是计数不对。

还有一次，我在屏障等待之后，某个线程直接退出了，但其他线程还在等下一轮屏障。嗯，这会导致屏障计数永远凑不齐，剩下的线程全部卡死。

多线程分治计算的典型流程

分治计算配合屏障，通常遵循这个模式：

1. 分解任务：将大任务拆成若干子任务，分配给各线程
2. 并行计算：每个线程独立处理自己的子任务
3. 屏障同步：所有线程在屏障处等待，确保子任务完成
4. 合并结果：通常由一个线程（或所有线程协作）合并子结果
5. 重复或结束：如果是多轮计算，回到步骤2；否则结束

下面这张图展示了这个流程：

你看，屏障就像一道闸门，把“计算”和“合并”两个阶段清晰地隔开了。这样做的好处是：你不需要用复杂的条件变量或全局标志来手动同步，屏障帮你搞定了。

性能与注意事项

屏障虽然好用，但也不是万能的。我个人的经验是：

• 不要滥用屏障：如果线程间不需要严格同步，用屏障反而会降低并行度。比如，每个线程独立写不同文件，就不需要屏障。
• 注意负载均衡：如果某个线程的任务特别重，其他线程会在屏障处空等。这时候可以考虑把任务切得更细，或者用动态分配。
• 屏障不是银弹：对于复杂的同步逻辑（比如生产者-消费者），条件变量更合适。

好了，关于屏障和栅栏，今天就聊到这儿。下次写多线程分治计算时，不妨试试 pthread_barrier_t，你会发现同步变得简单多了。

---