Question

因此，我对C语言中pthread的整个概念还很陌生，但是请听我说。我有以下代码：

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


static pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t   endCond = PTHREAD_COND_INITIALIZER;
static pthread_cond_t   startCond = PTHREAD_COND_INITIALIZER;

void * threadThingy(void * n){
    pthread_cond_wait(&startCond, &mutex);
    printf("%d: RAND: %d\n", *((int*)n), rand());

    //Lock mutex before broadcasting to main thread
    pthread_mutex_lock(&mutex);
    pthread_cond_broadcast(&endCond);
    pthread_mutex_unlock(&mutex);


    free(n);
    fflush(stdout);
    return 0;
}


int main(void){
    printf("Starting\n");
    pthread_t threads[100];
    int i = 0;

    while(i < 10){
        int *arg = malloc(sizeof(int));
        *arg = i;
        pthread_create(&threads[i], NULL, threadThingy, arg);
        i++;
    }

    pthread_mutex_lock(&mutex);
    pthread_cond_broadcast(&startCond);

    int finished = 0;

    while(finished <= 100){
        pthread_cond_wait(&endCond, &mutex);

        //Lock mutex so no other requests can come in
        pthread_mutex_lock(&mutex);
        finished++;

        int *arg = malloc(sizeof(int));
        *arg = 11;
        pthread_create(threads[i], NULL, threadThingy, arg);
        i++;
        pthread_cond_broadcast(&startCond);
        pthread_mutex_unlock(&mutex);

    }

    printf("Stopping\n");

    sleep(1000);
}

整个目标是在100个线程中同时运行（仅）10个线程。我的想法是启动10个线程，而不是等到一个线程完成再启动另一个线程。因此，我让程序等待线程返回，然后启动一个新线程，以便替换刚刚返回的线程。我错过了什么？因为现在我只能将其作为输出：

开始 0：RAND：1804289383

Answer 1

如Lavigne958所提到的，在threadThingy（）函数中，由于pthread_cond_wait（）会导致死锁，因为它将获取锁。同样，您尝试将其锁定在下一行。这会导致死锁。

有几件事需要检查：

您需要在调用pthread_cond_wait（）之前锁定互斥锁。
如果您解决了上述问题，则将多个条件变量与相同的互斥锁一起使用可能会导致进一步的死锁。
如果您不加入线程，最好使用PTHREAD_CREATE_DETACHED属性创建分离的线程。

可以使用一个信号量或一个条件变量（和一个互斥量）解决N个线程同时运行的问题。下面是带有信号量的示例。

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

sem_t mysem;
#define NUM_CONCURRENT_THREADS 4
#define MAX_THREADS 40

void *thread(void *arg)
{
        printf("Thread id %ld: started\n", pthread_self());
        sleep(5); // Do some work
        printf("Thread id %ld: Exiting\n", pthread_self());
        sem_post(&mysem);
        return NULL;
}


int main()
{
        pthread_t t[MAX_THREADS];
        pthread_attr_t attr;
        int rc, i = 0;

        sem_init(&mysem, 0, NUM_CONCURRENT_THREADS);
        rc = pthread_attr_init(&attr);
        rc = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

        printf("\nParent begin\n");
        while(i < MAX_THREADS)
        {
                sem_wait(&mysem);
                pthread_create(&t[i], &attr, thread, NULL);
                i++;
        }
        printf("\nParent end.\n");

        sem_destroy(&mysem);
        return 0;
}

请查看博客Tech Easy，以获取有关线程的更多信息。

Answer 2

在线程运行的功能中，您先等待某种条件，但之前忘记使用互斥锁。因此，您必须先使用互斥锁，然后再等待该条件。

您有所谓的僵局。

会发生什么：

第一个线程唤醒（pthread_con_wait函数已经为您获取了锁）
然后您尝试再次获取该锁=>死锁，因为您已经拥有该锁，因此您自己有点死锁。

C Pthread：仅同时运行10个线程（这里的问题是什么）

2 个答案: