如果我们的线程要等一个条件满足之后才可以继续向下执行，这个条件不满足的话，就要等待这个条件。这种场景经常见到，比如我们使用recv接收网络数据的时候，或者使用epoll_wait来等待事件的时候，在默认情况下，recv和epoll_wait都会等到有数据或者事件到来才会返回。
生产者和消费者的场景是条件变量典型的应用场景。一个队列，一个生产者，一个消费者，生产者向队列中生产数据，消费者从队列中消费数据。当队列满的时候，生产者就不能继续生产了，需要等有元素被消费之后才能继续生产；当队列空的时候，消费者不能继续消费数据了，需要有新的数据被生产才能继续消费。
具体怎么等待条件呢？有两种基本的方式：
轮询：
比如生产者在队列满的时候，通过轮询的方式不断地去确定队列是不是满，如果满，则继续等待；否则就继续生产数据。
条件：
当队列满的时候，生产者就睡眠，消费者消费数据之后，将生产者唤醒。
轮询和条件是两种基本的实现方式，这两种思想应用于很多场景，比如硬件和软件的通信方式：轮询和中断，中断就类似于这里的条件；比如多线程中使用的自旋锁和互斥体，前者是轮询的方式，后者是条件的方式。
本文讨论条件的方式。在linux中用户态和内核态均提供了这样的机制：用户态的条件变量，内核态的完成变量。
1用户态：条件变量
1.1使用
（1）条件变量要和互斥体mutex在一块使用
（2）wait的时候有两点需要注意
①wait之前要加锁，wait的时候会释放锁，wait返回之前会再次加锁。也就是说在函数pthread_cond_wait中，会有一次解锁和加锁的过程。
②wait返回之后要再次判断条件是不是满足，本例中消费者和生产者只有一个，而在实际使用中，生产者和消费者可能有多个。如果唤醒侧调用了pthread_cond_broadcast，那么等待者就会全部被唤醒，这样可能数据已经被先唤醒的线程消费了，后被唤醒的线程没有数据消费，所以需要加判断。这是条件变量的典型用法。
（3）wait侧使用方式
加锁
wait
解锁
（4）唤醒侧使用方式
加锁
signal/broadcast
解锁
唤醒侧其实也可以不加锁，也能起到唤醒的作用，如下man手册中所说。但是如果要求行为是可预知的，那么最好加锁。在实际应用中，我们当然需要代码的行为是可预知的，所以我们在使用中要加锁。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>#define BUFFER_SIZE 5int buffer[BUFFER_SIZE];
int count = 0;pthread_mutex_t mutex;
pthread_cond_t cond_producer;
pthread_cond_t cond_consumer;void* producer(void* arg) {for (int i = 0; i < 10; i++) {pthread_mutex_lock(&mutex);while (count == BUFFER_SIZE) {pthread_cond_wait(&cond_producer, &mutex);}buffer[count] = i;count++;printf("Produced: %d\n", i);pthread_cond_signal(&cond_consumer);pthread_mutex_unlock(&mutex);sleep(1);}return NULL;
}void* consumer(void* arg) {for (int i = 0; i < 10; i++) {pthread_mutex_lock(&mutex);while (count == 0) {pthread_cond_wait(&cond_consumer, &mutex);}count--;int item = buffer[count];printf("Consumed: %d\n", item);pthread_cond_signal(&cond_producer);pthread_mutex_unlock(&mutex);sleep(2);}return NULL;
}int main() {pthread_t prod_thread, cons_thread;pthread_mutex_init(&mutex, NULL);pthread_cond_init(&cond_producer, NULL);pthread_cond_init(&cond_consumer, NULL);pthread_create(&prod_thread, NULL, producer, NULL);pthread_create(&cons_thread, NULL, consumer, NULL);pthread_join(prod_thread, NULL);pthread_join(cons_thread, NULL);pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond_producer);pthread_cond_destroy(&cond_consumer);return 0;
}
1.2惊群问题
惊群问题说的是，如果有多个线程wait阻塞，这个时候一个线程调用signal，可能会唤醒多个线程。如下man手册中也说的是，pthread_cond_signal会唤醒至少一个线程，也就是说至少一个，也可能大于一个，大于一个就是惊群(你只扔了一个米粒，导致鸡群都跑了过来，但是只有一只鸡能够吃到米粒，其它的米都白跑一趟，惊动集群)。
本人在在linux环境下测试，从来没有出现过惊群问题。即使有惊群问题，通过如下典型的使用方式，在wait返回之后再次判断，也能避免惊群问题引入其它问题。
while (count == 0) {pthread_cond_wait(&cond_consumer, &mutex);
}1.3destroy无法返回问题
如果一个条件变量，有线程在wait这个条件变量。这个时候调用pthread_cond_destroy销毁条件变量，那么pthread_cond_destroy是会阻塞住，直到pthread_cond_wait返回之后，destroy才会成功。
在实际应用中，在类的析构函数里，或者进程的main函数返回时，需要销毁资源，往往会调用pthread_cond_destroy销毁条件变量，此时就要注意是不是有线程在wait。如果遇到destroy不返回的情况，要排查是不是有线程wait的情况。也可以使用pthread_cond_timedwait这个api，这个api不会一直等待，如果条件不满足，超时的时候，也会返回。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>pthread_mutex_t mutex;
pthread_cond_t cond_var;void *wait_thread(void *arg) {pthread_mutex_lock(&mutex);struct timespec ts;clock_gettime(CLOCK_REALTIME, &ts);ts.tv_sec += 5;pthread_cond_timedwait(&cond_var, &mutex, &ts);// pthread_cond_wait(&cond_var, &mutex);printf("Wait thread resumed.\n");pthread_mutex_unlock(&mutex);return NULL;
}void *destroy_thread(void *arg) {printf("before destroy condition.\n");pthread_cond_destroy(&cond_var);printf("after destroy condition.\n");return NULL;
}int main() {pthread_t wait_tid, destroy_tid;pthread_mutex_init(&mutex, NULL);pthread_cond_init(&cond_var, NULL);pthread_create(&wait_tid, NULL, wait_thread, NULL);sleep(1);pthread_create(&destroy_tid, NULL, destroy_thread, NULL);pthread_join(wait_tid, NULL);pthread_join(destroy_tid, NULL);pthread_mutex_destroy(&mutex);return 0;
}
2内核态：完成变量
如下是内核完成变量使用的例子。
struct completion声明一个完成变量，init_completion初始化完成变量，wait_for_completion等待完成，complete唤醒等待线程。另外，complete_all可以唤醒所有的等待线程。
| 用户态条件变量 | 内核态完成变量 |
| pthread_cont_t | struct completion |
| pthread_cond_init | init_completion |
| pthread_cond_wait | wait_for_completion |
| pthread_cond_signal | complete |
| pthread_cond_broadcast | complete_all |
源码：
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/kthread.h>MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple completion example module");static struct completion my_completion;
static struct task_struct *my_thread;static int my_thread_fn(void *data)
{printk(KERN_INFO "Thread is sleeping for 5 seconds...\n");ssleep(5);printk(KERN_INFO "Thread is completing...\n");complete(&my_completion);return 0;
}static int __init my_module_init(void)
{printk(KERN_INFO "Loading my completion module...\n");init_completion(&my_completion);my_thread = kthread_run(my_thread_fn, NULL, "my_thread");if (IS_ERR(my_thread)) {printk(KERN_ERR "Failed to create thread\n");return PTR_ERR(my_thread);}wait_for_completion(&my_completion);printk(KERN_INFO "Thread has completed!\n");return 0;
}static void __exit my_module_exit(void)
{printk(KERN_INFO "Unloading my completion module...\n");
}module_init(my_module_init);
module_exit(my_module_exit);
Makefile:
obj-m += comp.o
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
