为什么我的程序使用线程抛出 14000000 而不是 10000000？

Question

我编写了一个简单的 c 程序，让每个线程将其索引乘以 1000000 并将其添加到 sum 中，我创建了 5 个线程，因此逻辑答案将是 (0+1+2+3+4)*1000000 即 10000000但它会抛出 14000000 。任何人都可以帮助我理解这一点吗？

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

typedef struct argument {
    int index;
    int sum;
} arg;

void *fonction(void *arg0) {
    ((arg *) arg0) -> sum += ((arg *) arg0) -> index * 1000000;
}
int main() {
    pthread_t thread[5];
    int order[5];
    arg a;
    for (int i = 0; i < 5; i++)
        order[i] = i;
    a.sum = 0;
    for (int i = 0; i < 5; i++) {
        a.index = order[i];
        pthread_create(&thread[i], NULL, fonction, &a);
    }
    for (int i = 0; i < 5; i++)
        pthread_join(thread[i], NULL);

    printf("%d\n", a.sum);

    return 0;
}

Answer 1

它是 140.. 因为行为未定义。不同机器和其他环境因素的结果会有所不同。未定义的行为是由于所有线程访问同一对象（请参阅为每个线程提供的&a）导致的，该对象在创建第一个线程后被修改。

• 当每个线程运行时，它访问相同的index（作为访问同一对象的成员（&a）的一部分）。因此，线程将看到 [0,1,2,3,4] 的假设是不正确的：多个线程可能看到 index 的相同值（例如 [0,2,4, 4,4]¹) 运行时。这取决于循环创建线程的调度，因为它也会修改共享对象。

• 当每个线程更新sum 时，它必须读取和写入相同的共享内存。这本质上容易出现竞争条件和不可靠的结果。例如，它可能是缺乏内存可见性（线程 X 没有看到从线程 Y 更新的值）或者它可能是读取和写入之间的冲突线程调度（线程 X 读取，线程 Y 读取，线程 X 写入，线程Y写）等。

如果为每个线程创建 一个新的 arg 对象，那么这两个问题都可以避免。虽然总和问题可以通过适当的锁定来解决，但索引问题只能通过不共享作为线程输入给出的对象来解决。

// create 5 arg objects, one for each thread
arg a[5];

for (..) {
    a[i].index = i;
    // give DIFFERENT object to each thread
    pthread_create(.., &a[i]);
}

// after all threads complete
int sum = 0;
for (..) {
    sum += a[i].result;
}

---

¹ 即使假设当前执行 wrt 中没有竞争条件。 sum的用法，不同线程看到index值的顺序为[0,2,4,4,4]，总和为14，可能如下所示：

1. a.index
2. 线程 A 读取 a.index (0)
3. a.index
4. a.index
5. 线程 B 读取 a.index (2)
6. a.index
7. a.index
8. 线程 D 读取 a.index (4)
9. 线程 C 读取 a.index (4)
10. 线程 E 读取 a.index (4)