Linux pthread_cond_wait从不解除阻止-线程池

我正在尝试实现一种线程池，通过它，我将线程保存在FIFO中，并处理一组图像。不幸的是，由于某种原因，我的cond_wait并不总是醒着，即使它已发出信号

        // Initialize the thread pool
        for(i=0;i<numThreads;i++)
        {

            pthread_t *tmpthread = (pthread_t *) malloc(sizeof(pthread_t));

            struct Node* newNode;
            newNode=(struct Node *) malloc(sizeof(struct Node));
            newNode->Thread = tmpthread;
            newNode->Id = i;
            newNode->threadParams = 0;
            pthread_cond_init(&(newNode->cond),NULL);
            pthread_mutex_init(&(newNode->mutx),NULL);

            pthread_create( tmpthread, NULL, someprocess, (void*) newNode);
            push_back(newNode, &threadPool);

        }



    for() //stuff here
    {
    //...stuff
        pthread_mutex_lock(&queueMutex);        
            struct Node *tmpNode = pop_front(&threadPool);
        pthread_mutex_unlock(&queueMutex);  

        if(tmpNode != 0)
        {
            pthread_mutex_lock(&(tmpNode->mutx));
                pthread_cond_signal(&(tmpNode->cond)); // Not starting mutex sometimes? 
            pthread_mutex_unlock(&(tmpNode->mutx));     
        }
    //...stuff
    }

 destroy_threads=1;
 //loop through and signal all the threads again so they can exit. 
 //pthread_join here


}

    void *someprocess(void* threadarg)
    {
        do
        {
    //...stuff
            pthread_mutex_lock(&(threadNode->mutx));
                pthread_cond_wait(&(threadNode->cond), &(threadNode->mutx));
                // Doesn't always seem to resume here after signalled.
            pthread_mutex_unlock(&(threadNode->mutx));
        } while(!destroy_threads);

        pthread_exit(NULL);
    }

//初始化线程池
对于（i=0；iThread=tmpthread；
newNode->Id=i；
newNode->threadParams=0；
pthread_cond_init（&（newNode->cond），NULL）；
pthread_mutex_init（&（newNode->mutx），NULL）；
pthread_create（tmpthread，NULL，someprocess，（void*）newNode）；
推回（新节点和线程池）；
}
这里的东西
{
//…东西
pthread_mutex_lock（&queueMutex）；
结构节点*tmpNode=pop_-front（&threadPool）；
pthread_mutex_unlock（&queueMutex）；
如果（tmpNode！=0）
{
pthread_mutex_lock（&（tmpNode->mutx））；
pthread_cond_signal（&（tmpNode->cond））；//有时不启动互斥锁？
pthread_mutex_unlock（&（tmpNode->mutx））；
}
//…东西
}
销毁_线程=1；
//循环并再次向所有线程发送信号，以便它们可以退出。
//pthread_在这里加入
}
void*someprocess（void*threadarg）
{
做
{
//…东西
pthread_mutex_lock（&（threadNode->mutx））；
pthread_cond_wait（&（threadNode->cond），&（threadNode->mutx））；
//在发出信号后，似乎并不总是在这里恢复。
pthread_mutex_unlock（&（threadNode->mutx））；
}而（！销毁_线程）；
pthread_exit（NULL）；
}

我是不是遗漏了什么？大概有一半的时间是这样的，所以我会假设我在某个地方有一场比赛，但我能想到的唯一一件事是我把互斥锁搞糟了？我读到了一些关于锁定前不发信号之类的东西，但我真的不明白发生了什么

有什么建议吗

---

谢谢！

我不确定，但我认为在调用pthread_cond_signal（&（tmpNode->cond））之前，您不必（一定不要）在线程池中锁定互斥体，否则，被唤醒的线程将无法将互斥体作为pthread_cond_wait（&（threadNode->cond），&（threadNode->mutx））的一部分锁定；操作。

首先，您的示例显示您在调用

pop\u front

时锁定了

queueMutex

，而不是round

push\u back

。通常您需要同时锁定这两个，除非您可以保证所有推送都在所有pop之前发生

其次，对

pthread\u cond\u wait

的调用似乎没有关联的谓词。条件变量的典型用法是：

pthread_mutex_lock(&mtx);
while(!ready)
{
    pthread_cond_wait(&cond,&mtx);
}
do_stuff();
pthread_mutex_unlock(&mtx);

在本例中，

ready

是由另一个线程设置的变量，而该线程在

mtx

上持有锁

---

如果调用

pthread\u cond\u wait

时，在

pthread\u cond\u wait

中未阻止等待线程，则该信号将被忽略。关联的

ready

变量允许您处理此场景，还允许您处理所谓的虚假唤醒，其中调用

pthread\u cond\u wait

returns没有从另一个线程调用

pthread\u cond\u signal

。

谢谢，但不幸的是，它仍然会导致相同的问题：（当然会。一旦释放互斥锁，它就会锁定互斥锁。只要你最终释放互斥锁，你就可以一直保持互斥锁。不幸的是，“pthread_cond_wait”的名称令人困惑。它不是条件等待，而是对条件的无条件等待。如果你不需要等待，就不能调用它。是的，这是y请说明需要

ready

变量或其他关联谓词的另一个原因。