c - 如何完成多个线程以多次加入一个进程？ (pthread_mutex_lock)

Question

我想编写一个程序，计数为100。我想使用pthread锁使用10个线程来完成此任务。当程序进入线程时，它会生成一个介于0到2之间的数字，该值将被添加到其数组的索引以及全局变量sum中。当总和达到100时，每个线程应打印其自己的数组值（整个数组的数量应与sum变量相等）。

我的问题如下：始终第一个线程锁定互斥锁变量，但是我想在所有线程之间分配任务（arr [1] = 100，每隔= 0，但是我想例如arr [1] = 14， arr [2] = 8，依此类推，最多100个）。我哪里错了？

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>

pthread_mutex_t mutex;
int arr[10];
int sum = 0;

void *add (void* input){

    int *id = (int*) input, x, s;
    int ind = *id;
    while (sum < 100){
        while (1){
            if (pthread_mutex_trylock(&mutex) != EBUSY)
                break;
        }
        if (sum < 100){
            x = rand() % 3;
            arr[ind] = arr[ind] + x;
            sum += x;
        }
        pthread_mutex_unlock(&mutex);
        sleep(0.1);
    }
    printf("The %d. thread got %d points!\n", ind, arr[ind]);
    return NULL;
}

int main (void){

    int i;
    pthread_t threads[10];
    pthread_mutex_init(&mutex, NULL);
    srand(time(NULL));
    for (i = 0; i < 10; i++){
        if (pthread_create(&threads[i], NULL, add, &i)){
            perror("pthread_create");
            exit(1);
        }
    }
    for (i = 0; i < 10; i++){
        if (pthread_join (threads[i], NULL)){
            perror("pthread_join");
        }
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}

输出：

1.线程获得100分！

2.线程得到0分！

3.线程得到0分！

4.线程得到0分！

5.线程得到0分！

6.线程得到0分！

7.线程得到0分！

8.线程得到0分！

9.线程得到0分！

0.线程得到0分！

Answer 1

您的代码中有几个问题，与您所询问的特定问题的相关程度不同。在继续之前，我从运行您编写的代码中获得的输出可能是说明性的：

The 2. thread got 100 points!
The 8. thread got 0 points!
The 9. thread got 0 points!
The 5. thread got 0 points!
The 5. thread got 0 points!
The 6. thread got 0 points!
The 7. thread got 0 points!
The 2. thread got 100 points!
The 4. thread got 0 points!
The 1. thread got 0 points!

请注意，某些线程具有相同的计数器索引。之所以会发生这种情况，是因为您在主线程和每个子线程之间存在数据争用：主线程将指针传递给其局部变量 i，然后继续修改该变量的值。同时，子线程通过指针读取变量的值。这些动作未同步，因此行为未定义。

这个特殊的问题有几种解决方案。最简单的方法可能是将 i强制转换为 void *并传递结果（按值）。实际上，这很普遍，您只想传递一个整数：

        if (pthread_create(&threads[i], NULL, add, (void *)i)) {
            // ...

当然，线程函数需要将其转换回：

void *add (void* input) {
    int /*no need for 'id' */ x, s;
    int ind = (int) input;
    // ...

接下来，观察在所有子线程之间还有另一个数据争用，在这些子线程中，在 sum循环的条件下读取 while的值。该人员目前似乎没有在咬你，但随时都可以。由于线程作为一个组读取和修改 sum，因此必须确保所有此类访问都是同步的-例如，仅在保持互斥锁锁定的情况下执行这些访问。

跳过一点（我们会回来），您的 sleep()调用有问题。该函数的参数的类型为 int，因此您的实际参数 double 0.1会转换为 int，产生0。禁止行动。但是，更重要的是。 sleep()仅仅是此工作或几乎所有与线程间同步和计时有关的工作的错误工具。

现在认识到没有睡眠，您应该看到外部 while循环非常紧密，因为刚刚解锁了互斥锁的线程将立即尝试再次锁定它。这种重新锁定尝试在第一次尝试中成功的情况非常普遍，因为默认的互斥行为无法保证线程调度的公平性。

此外， pthread_mutex_trylock()周围的特殊忙碌循环不会给您带来特别的好处。如果重试互斥锁繁忙，您只需执行 pthread_mutex_lock()即可。这将节省您的CPU时间，并且没有明显不同的语义。

总体而言，您有策略问题。互斥体通常不会为公平调度提供任何保证。通常，对于像这样的紧密多线程交互，您需要手动执行某种调度管理，通常通过向混合中添加条件变量而大大受益。

看起来您不想强迫线程轮流使用，但也许足以确保刚运行的线程不会立即再次被选中。在这种情况下，您可以添加一个共享变量，该变量记录刚运行的线程的索引，并使用该变量防止再次将其选择为下一个线程。从原理上讲，线程函数可能看起来像这样


无限循环：


锁定互斥锁
无限循环：


比较最后一个线程索引和我的索引
如果不同，则中断（内部）循环
否则等待条件变量

将我的索引设置为最后一个线程索引
（仍保持互斥锁处于锁定状态）向CV广播或发出信号
如果 sum小于100


更新 sum
解锁互斥锁

否则（ sum> = 100）


解锁互斥锁
从（外部）循环中打破