怎么知道哪一个线程被调用pthread_cond_signal

Question

干杯发布，

我有2个线程导致逻辑僵局=> d_santa和d_patuljak（抱歉，有些作品写在克罗地亚和我没有翻译的时间）

d_santa做到这一点

void d_santa(){ //dodati join!!! 
    int j; 
    pthread_mutex_lock(&m); 
    while(1){ 
     pthread_cond_wait(&u_santa,&m); 
     if ((br_sob==10)&&(br_patuljak)){ 
      printf ("Dajem poklone i rijesavam se sobova\n"); 
      pthread_cond_broadcast(&u_sob); 
      sleep(2); 
      for (j=2; j<=11; j++){ 
       printf ("Pokusavam brisat sob na %d\n",j); 
       pthread_join(thred[j],NULL); 
       br_sob--; 
       printf ("broj sobova=%d\n",br_sob); 
      } 
     } 
     if (br_sob==10){ 
      printf("Hrani nezahvalnu bagru\n"); 
      sleep(2); 
     } 
     if ((br_patuljak%3)==0){ 
      pthread_cond_broadcast(&u_patuljak); 
      printf ("Rijesi problem patuljaka\n"); 
      sleep(1);    
      for (j=0; j<3; j++){ 
       br_ulaz++; 
       printf("Oslobađam dretvu %d\n",H_ULAZ); 
       pthread_join(thred[H_ULAZ],NULL);         
       br_patuljak--; 
       } 
     } 
    } 
    pthread_mutex_unlock(&m); 
} 

和d_patuljak做到这一点

void d_patuljak(){ //zavrsi implementaciju proizvodac potrosac 
    pthread_mutex_lock(&m); 
    br_patuljak++; 
    printf ("Nastao je patuljak %d\n",br_patuljak); 
    while(br_patuljak<3){ 
     pthread_cond_wait(&u_patuljak,&m); 
    } 
    printf ("Patuljak se oslobodio\n"); 
    if (br_patuljak==3){ 
     pthread_cond_signal(&u_santa); 
    } 
    pthread_mutex_unlock(&m); 
} 

这里也d_sob如果它可以帮助

void d_sob(){ //dobar 
    int id; 
    pthread_mutex_lock(&m); 
    id=br_sob+2;  
    br_sob++; 
    printf ("Nastao je sob %d\n",br_sob); 
    while(br_sob<10){ 
     pthread_cond_wait(&u_sob,&m); 
    } 
    pthread_cond_signal(&u_santa); 
    printf ("Sob ceka slobodu %d, a za analizu br_sob=%d\n",id,br_sob); 
    pthread_mutex_unlock(&m); 
} 

任务： d_santa仅创建一次，并始终保持睡觉或做一些“有用”，而d_patuljak不断创建和一组3在创建时他们醒来圣诞老人等等他可以帮助他们解决所有问题（请注意，如果d_patuljak的创建速度很快，那么可能会有超过3个patuljaks，但圣诞老人只需要一组3个！）。 类似的啜泣，他们不断创建，直到他们达到10后，他们可以播出（不能有11人）

我的解决方案（想法）： 我会创建1,2,3 patuljaks每个都有自己的阵列位置。 当patuljak 3创建时，他会唤醒圣诞老人（也绕过pthread_cond_wait）！ 圣诞老人将醒来，并连续调用3个pthread_cond_signals来释放patuljak 1，patuljak 2然后patuljak 3 =>注意：patuljak 1释放以结束他的线程，然后被pthread_join''销毁'，我将它放在pthread_cond_signal下面！

问题： pthread_join（patuljak 1）一直在等待patuljak 1，这意味着pthread_cond_signal没有设法释放patuljak 1（可能是patuljak 2或3）？我不知道解决这个问题的方法是否有一种方法知道将会发布什么或者如何准确地发布patuljak 1,2,3？我会使用广播，但我不能patuljak 4将被释放，圣诞老人应该只采取3组。编辑：我切换pthread_cond_signal与pthread_cond_broadcast patuljaks问题没有消失。

无论如何，这个程序比这更大地我有一个raindeers（= sob）类似的问题，我可以尝试播出，但他们也卡在pthread_join，我有一种感觉，如果patuljaks的问题解决了对于降雨者（patuljak =>侏儒）xd也是如此。

Answer 1

两个规则将解决问题的这些类型：

1. 只有调用pthread_cond_signal时任何线程可能会等待条件变量可以做什么，那就是需要完成的。否则，总是致电pthread_cond_broadcast。如有疑问，请致电pthread_cond_broadcast，因为它总是安全的。

2. 总是在一个循环内呼叫pthread_cond_wait，该循环在发生虚假唤醒时再次调用pthread_cond_wait。你必须设计你的代码，以便“额外”的唤醒是无害的，如果线程在“不应该”的时候唤醒，线程就会回到睡眠状态。

Answer 2

如果你想知道哪个线程被释放，一个简单的方法是打印线程ID区分。请参阅Pthread Creation and Termination

void *PrintHello(void *threadid) 
{ 
    long tid; 
    tid = (long)threadid; 
    printf("Hello World! It's me, thread #%ld!\n", tid); 
    pthread_exit(NULL); 
} 


int main (int argc, char *argv[]) 
{ 
    pthread_t threads[NUM_THREADS]; 
    int rc; 
    long t; 
    for(t=0; t<NUM_THREADS; t++){ 
     printf("In main: creating thread %ld\n", t); 
     rc = pthread_create(&threads[t], NULL, PrintHello, (void *)t); 
     if (rc){ 
     printf("ERROR; return code from pthread_create() is %d\n", rc); 
     exit(-1); 
     } 
    } 

    /* Last thing that main() should do */ 
    pthread_exit(NULL); 
} 

所以，你可以修改你的线程函数就像

void d_santa(void *threadid) { 
} 

Answer 3

所以实际的解决方案（由特级大师JAX）是：

d_patuljak

void d_patuljak(){ //zavrsi implementaciju proizvodac potrosac 
    pthread_mutex_lock(&m); 
    br_patuljak++; 
    printf ("Nastao je patuljak %d\n",br_patuljak); 
    if (br_patuljak==3) 
    { 
     pthread_cond_signal(&u_santa); 
    } 
    while(varijabla<=0) 
    { 
     pthread_cond_wait(&u_patuljak,&m); 
    } 
    varijabla--; 
    printf ("SLOBODA\n"); 
    pthread_mutex_unlock(&m); 
} 

d_santa

void d_santa(){ //dodati join!!! 
    int j; 
    pthread_mutex_lock(&m); 
    while(1){ 
     pthread_cond_wait(&u_santa,&m); 
     if ((br_sob==10)&&(br_patuljak)){ 
      printf ("Dajem poklone i rijesavam se sobova\n"); 
      pthread_cond_broadcast(&u_sob); 
      sleep(2); 
      for (j=2; j<=11; j++){ 
       varijabla2++;    
      } 
      br_sob=br_sob-10; 
     } 
     if (br_sob==10){ 
      printf("Hrani nezahvalnu bagru\n"); 
      sleep(2); 
     } 
     if (br_patuljak>=3){ 
      printf ("Rijesi problem patuljaka\n");    
      sleep(1); 
      for (j=0; j<3; j++){ 
       varijabla++; 
       pthread_cond_signal(&u_patuljak);         
      } 
      br_patuljak=br_patuljak-3; 
     } 
    } 
    pthread_mutex_unlock(&m); 
} 

相同的解决方案可以应用于d_sob ....简而言之，问题是在while（）中的条件，第一个线程将是空闲的，然后减少将锁定其他线程的计数器。