理解pthread_cond_wait（）和pthread_cond_signal（）

Question

一般来说，pthread_cond_wait（）和pthread_cond_signal（）的调用如下：

//thread 1:
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
do_something()
pthread_mutex_unlock(&mutex);

//thread 2:
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);  
pthread_mutex_unlock(&mutex);

步骤是

>

线程2锁定互斥锁并调用pthread\u cond\u signal（），从而解锁互斥锁

在线程1中，调用pthread\u cond\u wait（），并再次锁定互斥锁

现在在线程2中，在调用pthread\u cond\u signal（）之后，pthread\u mutex\u unlock(

此外，在我看来，pthread\u cond\u wait（）。但有一种说法是“pthread_cond_signal（）函数应解除阻塞指定条件变量cond上阻塞的至少一个线程（如果任何线程在cond上阻塞）。”那么，这意味着对于同一个cond互斥对，多个线程可以调用pthread\u cond\u wait（）？




Answer 1

我在这里举了个例子https://www.geeksforgeeks.org/condition-wait-signal-multi-threading/

并修改成这样,，

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

// Declaration of thread condition variable 
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 

// declaring mutex 
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; 

// Thread function 
void releaseFun() 
{ 
    // Let's signal condition variable cond
    printf("Signaling condition variable cond\n"); 
    pthread_cond_signal(&cond); 
}

// Thread function 
void* blockedThread() 
{
    // acquire a lock 
    pthread_mutex_lock(&lock); 
    printf("Waiting on condition variable cond\n");
    pthread_cond_wait(&cond, &lock); 
    // release lock 
    pthread_mutex_unlock(&lock); 

    printf("Returning thread\n"); 

    return NULL; 
}    

// Driver code 
int main() 
{ 
    pthread_t tid;

    // Create thread 1 
    pthread_create(&tid, NULL, blockedThread, NULL); 

    // sleep for 1 sec so that thread 1 
    // would get a chance to run first 
    sleep(1); 

    releaseFun();
    // wait for the completion of thread 2 
    pthread_join(tid, NULL); 

    return 0; 
}

输出：gcc测试线程。c-LPTThread

等待条件变量cond

信令条件可变条件

返回线程

只有当blockThread的pthread_cond_wait（）函数发出解除阻塞的信号时，才会锁定和解锁线程。

Answer 2

下面是一个典型示例：线程1正在等待一个条件，该条件可能由线程2实现。

我们使用一个互斥和一个条件。

pthread_mutex_t mutex;
pthread_cond_t condition;

线程1：

pthread_mutex_lock(&mutex); //mutex lock
while(!condition){
    pthread_cond_wait(&condition, &mutex); //wait for the condition
}

/* do what you want */

pthread_mutex_unlock(&mutex);

线程2：

pthread_mutex_lock(&mutex);

/* do something that may fulfill the condition */

pthread_mutex_unlock(&mutex);
pthread_cond_signal(&condition); //wake up thread 1

编辑

正如您在pthread_cond_wait手册中看到的：

它以原子方式释放互斥锁，并导致调用线程阻塞条件变量cond；原子性在这里意味着“原子性地涉及到另一个线程对互斥体的访问，然后是对条件变量的访问”。

Answer 3

pthread_cond_signal不解锁互斥锁（它不能，因为它没有对互斥锁的引用，所以它怎么知道要解锁什么？）事实上，信号不需要与互斥锁有任何连接；信令线程不需要持有互斥锁，尽管对于大多数基于条件变量的算法来说，它会持有。

pthread\u cond\u wait在互斥体Hibernate之前解锁（如您所注意的），但当发出信号时，它会在唤醒之前重新请求互斥体（可能需要等待）。因此，如果信令线程持有互斥锁（通常情况下），等待线程将不会继续，直到信令线程也解锁互斥锁。

条件变量的常见用法如下：

thread 1:
    pthread_mutex_lock(&mutex);
    while (!condition)
        pthread_cond_wait(&cond, &mutex);
    /* do something that requires holding the mutex and condition is true */
    pthread_mutex_unlock(&mutex);

thread2:
    pthread_mutex_lock(&mutex);
    /* do something that might make condition true */
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

这两个线程有一些共享的数据结构，互斥体保护对这些结构的访问。第一个线程希望等待某个条件为真，然后立即执行某个操作（没有争用条件机会让其他线程在条件检查和操作之间进入，并使条件为假）第二个线程正在做一些可能使条件变为真实的事情，因此它需要唤醒可能正在等待它的任何人。