同时启动所有线程

Question

我在理解诸如pthread\u mutex\u lock/unlock和pthread\u cond\u wait/signal

我试图创建九个线程，并让它们同时运行，以找出哪个是最有效的。

    int threadNumber = 0;
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

    #define NUM_THREADS    9

    //used to store the information of each thread
    typedef struct{
        pthread_t  threadID;
        int policy;
        struct sched_param param;
        long startTime;
        long taskStartTime;
        long endTime1;
        long endTime2;
        long endTime3;
        long runTime;
        char startDate[30];
        char endDate[30];
    }ThreadInfo;

ThreadInfo myThreadInfo[NUM_THREADS];



//main function
int main(void){

   printf("running...\n");

   pthread_mutex_lock(&mutex); //lock the mutex//////
   pthread_cond_wait(&cond, &mutex); //start waiting//////


   int fifoPri = 60;
   int rrPri = 30;

   //create the 9 threads and assign their scheduling policies
   for(int i=0; i<NUM_THREADS; i++){

      if(i%3 == SCHED_OTHER){
            myThreadInfo[i].policy = SCHED_OTHER;
            myThreadInfo[i].param.sched_priority = 0;

      }
      else if (i%3 == SCHED_RR){ 
            myThreadInfo[i].policy = SCHED_RR;
            myThreadInfo[i].param.sched_priority = rrPri++; 
      }

      else{
            myThreadInfo[i].policy = SCHED_FIFO; 
            myThreadInfo[i].param.sched_priority = fifoPri++; 

      }

      pthread_create( &myThreadInfo[i].threadID, NULL, ThreadRunner, &myThreadInfo[i]);

   }

   printf("\n\n");

   pthread_mutex_unlock(&mutex) //unlock the mutex/////////
   pthread_cond_signal(&cond); //signal the threads to start////////


   //join each thread
   for(int g = 0; g < NUM_THREADS; g++){
      pthread_join(myThreadInfo[g].threadID, NULL);
   }


   //print out the stats for each thread and perform an analysis of the data
   DisplayThreadSchdStats();


   return 0;
}

...

因此，当主函数启动时，我会锁定互斥锁，以确保线程不会启动，然后再告诉它们使用pthread_lock(

然后，我使用各种调度策略创建所有九个线程。完成后，我尝试使用pthread\u mutex\u unlock告诉所有线程同时启动(

但当我运行这个时，它永远不会解锁线程。主功能的“运行…”print语句将关闭，但线程从未启动。（threadrunner有一个功能，它们都打印出大量不同的数字，这样我就可以看到它们是否启动了）。pthread互斥体和pthread cond有什么错？

Answer 1

我想你想做的就是这样。我使用pthread\u cond\u broadcast一次唤醒所有线程：

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


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

struct data_t {
    int id;
    int sleep;
};

void* thread(void *arg)
{
    struct data_t *data = arg;


    pthread_mutex_lock(&mutex);
    printf("Thread %d: waiting for release\n", data->id);

    pthread_cond_wait(&cond, &mutex);
    pthread_mutex_unlock(&mutex); // unlocking for all other threads

    struct timeval tv;
    gettimeofday(&tv, NULL);    

    printf("Thread %d: doing some work for %d secs, started: %ld...\n", data->id, data->sleep, tv.tv_sec);
    sleep(data->sleep);
    gettimeofday(&tv, NULL);    
    printf("Thread %d: Bye, end at %ld\n", data->id, tv.tv_sec);
}

int main(void)
{

    struct data_t data[9];
    pthread_t ths[9];

    srand(time(NULL));

    for(int i = 0; i < 9; ++i)
    {
        data[i].id = i + 1;
        data[i].sleep = 1 + rand() % 6;

        pthread_create(ths + i, NULL, thread, data + i);
    }

    // give time for all threads to lock
    sleep(1);

    printf("Master: Now releasing the condition\n");

    pthread_cond_broadcast(&cond);

    for(int i = 0; i < 9; ++i)
        pthread_join(*(ths + i), NULL);

    return 0;
}

输出是

Thread 2: waiting for release
Thread 6: waiting for release
Thread 4: waiting for release
Thread 1: waiting for release
Thread 3: waiting for release
Thread 8: waiting for release
Thread 9: waiting for release
Thread 7: waiting for release
Thread 5: waiting for release
Master: Now releasing the condition
Thread 5: doing some work for 6 secs, started: 1518463908...
Thread 2: doing some work for 4 secs, started: 1518463908...
Thread 8: doing some work for 1 secs, started: 1518463908...
Thread 4: doing some work for 4 secs, started: 1518463908...
Thread 6: doing some work for 1 secs, started: 1518463908...
Thread 9: doing some work for 5 secs, started: 1518463908...
Thread 3: doing some work for 2 secs, started: 1518463908...
Thread 1: doing some work for 3 secs, started: 1518463908...
Thread 7: doing some work for 2 secs, started: 1518463908...
Thread 8: Bye, end at 1518463909
Thread 6: Bye, end at 1518463909
Thread 3: Bye, end at 1518463910
Thread 7: Bye, end at 1518463910
Thread 1: Bye, end at 1518463911
Thread 2: Bye, end at 1518463912
Thread 4: Bye, end at 1518463912
Thread 9: Bye, end at 1518463913
Thread 5: Bye, end at 1518463914

Answer 2

从pthread\u cond\u wait（）手册页：

函数pthread_cond_wait（）以原子方式阻止当前线程在cond指定的条件变量上等待，并释放mutex指定的互斥。

...所以当你的main（）函数到达这一行时：

pthread_cond_wait(&cond, &mutex); //start waiting//////

... 如条件所示，直到有人发出您的注释信号为止。

但是还没有生成其他线程，因此没有人向条件变量发送信号，因此主线程在该调用中无限期地阻塞。

Answer 3

就临时基准而言，公认的答案是“足够好”。然而，它使用了几个有问题的实践：不带谓词的条件变量和替代同步的睡眠（）。

使用pthreadsbarrier对象更好、更简单。

#define NUM_THREADS ...

static pthread_barrier_t bar;

static void*
thrfunc(void *arg) {
  // set scheduling policy

  pthread_barrier_wait(&bar); // wait till all peers have also done so

  ...
}

int
main(void) {
  pthread_barrier_init(&bar, NULL, NUM_THREADS); // FIXME: error check

  for (int i = 0; i < NUM_THREADS; i++) {
    // spawn threads with various scheduling policy instructions
  }

  // join and tabulate results

  pthread_barrier_destroy(&bar);

  ...
}

但是如果你的平台不支持壁垒怎么办？在这种情况下，您可以实现“一次性障碍”，等待N方到达。

您的主线程将init_quorum（NUM_THREADS），而辅助角色将await_quorum（...），只有当所有辅助角色都准备好时才前进。

struct quorum {
  pthread_cond_t  cond;
  pthread_mutex_t mut;
  size_t          count;  // How many are needed?
};

void
await_quorum(struct quorum *q) {  // FIXME: error checking
  pthread_mutex_lock(&q->mut);

  if (q->count > 0) {
    q->count--;

    if (q->count == 0) {
      // I'm the last needed; we have quorum
      pthread_cond_broadcast(&q->cond);
    } else {
      // Wait for sufficient threads to arrive
      while (q->count > 0)
        pthread_cond_wait(&q->cond, &q->mut);
    }
  } // else quorum already achieved; I'm late!

  pthread_mutex_unlock(&q->mut);
}