并行线程经Barrier同步后数组元素值不一致的原因分析

我让多个线程并行对数组中各自对应的元素执行自增操作，每个线程仅修改自己的元素，不改动其他线程的元素。每次自增后设置Barrier，让所有线程等待彼此完成后再进入下一轮循环。我本以为每次所有线程到达Barrier时，数组中所有元素的值应该相等，但实际并非总是如此，请问这是为什么？

代码示例 #

#include <iostream>
#include <omp.h>
#include <vector>
#include <chrono>

int main() {
    const int num_threads = 4;
    const auto start_time = std::chrono::high_resolution_clock::now();
    std::vector<int> arr(num_threads, 0);

    #pragma omp parallel num_threads(num_threads)
    {
        int thread_num = omp_get_thread_num();
        while (true) {
            // 检查运行时间
            auto now = std::chrono::high_resolution_clock::now();
            auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - start_time).count();
            if (elapsed >= 10) break;

            
            arr[thread_num]++;
            std::cout << "Thread " << thread_num << " done grinding.\n";
            
            #pragma omp barrier // 等待其他线程完成

            // 检查其他线程的元素值
            for (int i = 0; i < num_threads; ++i) {
                if (i != thread_num && arr[i] != arr[thread_num]) {
                    std::cout << "Thread " << thread_num << ": My value is " << arr[thread_num] 
                              << ", but thread " << i << "'s value is " << arr[i] << ".\n";
                }
            }
        }
    }

    std::cout << "Final array values:\n";
    for (int i = 0; i < num_threads; ++i) {
        std::cout << "Index " << i << ": " << arr[i] << "\n";
    }

    return 0;
}

输出（末尾部分） #

Thread 3 done grinding.
Thread 2 done grinding.
Thread 1: My value is 271402, but thread 2's value is 271403.
Thread 1 done grinding.
Thread 3: My value is 271402, but thread 1's value is 271403.
Thread 3: My value is 271402, but thread 2's value is 271403.
Thread 0: My value is 271402, but thread 2's value is 271403.
Thread 1: My value is 271403, but thread 0's value is 271402.
Thread 1: My value is 271403, but thread 3's value is 271402.
Thread 2: My value is 271403, but thread 0's value is 271402.
Thread 2: My value is 271403, but thread 3's value is 271402.
Final array values:
Index 0: 271402
Index 1: 271403
Index 2: 271403
Index 3: 271402

问题分析与解决 #

核心原因 #

1. 退出条件无同步检查
   每个线程独立判断elapsed >=10的退出时机，完全由操作系统线程调度决定。当时间接近10秒临界值时，部分线程可能刚完成一轮自增并通过Barrier，而另一些线程可能进入循环后直接触发退出，没执行本轮自增，导致最后一轮循环中部分元素多了一次自增，值出现差异。

2. 线程执行节奏差异
   操作系统对线程的调度存在不确定性，即使时间未到10秒，不同线程的循环执行速度也可能因CPU负载、线程优先级等因素略有不同。Barrier只能保证所有线程完成当前轮自增后再继续，但无法强制所有线程的循环次数完全对齐——因为退出条件是各自独立判断的，某些线程可能在时间临界时多跑了一轮。

修复方案 #

要让所有线程的自增次数完全一致，必须同步退出条件的判断逻辑，确保所有线程同时决定是否进入下一轮循环。修改后的核心逻辑如下：

#pragma omp parallel num_threads(num_threads)
{
    int thread_num = omp_get_thread_num();
    bool keep_running = true;
    while (keep_running) {
        // 执行自增操作
        arr[thread_num]++;
        std::cout << "Thread " << thread_num << " done grinding.\n";
        
        // 等待所有线程完成自增
        #pragma omp barrier
        
        // 仅由线程0统一检查退出条件，同步给所有线程
        #pragma omp single
        {
            auto now = std::chrono::high_resolution_clock::now();
            auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - start_time).count();
            keep_running = (elapsed < 10);
        }
        
        // 等待所有线程获取退出状态
        #pragma omp barrier
        
        // 仅在继续运行时检查其他线程的值
        if (keep_running) {
            for (int i = 0; i < num_threads; ++i) {
                if (i != thread_num && arr[i] != arr[thread_num]) {
                    std::cout << "Thread " << thread_num << ": My value is " << arr[thread_num] 
                              << ", but thread " << i << "'s value is " << arr[i] << ".\n";
                }
            }
        }
    }
}

通过#pragma omp single让单个线程统一判断退出条件，再通过Barrier同步所有线程的keep_running状态，就能保证所有线程执行的循环次数完全相同，数组元素值也会始终保持一致。

内容的提问来源于Stack Exchange，提问作者Roman Reimche