POSIX 条件变量详细解析

条件锁pthread_cond_t

说明，
等待线程
1。使用pthread_cond_wait前要先加锁
2。pthread_cond_wait内部会解锁，然后等待条件变量被其它线程激活
3。pthread_cond_wait被激活后会再自动加锁

激活线程：
1。加锁（和等待线程用同一个锁）
2。pthread_cond_signal发送信号
3。解锁
激活线程的上面三个操作在运行时间上都在等待线程的pthread_cond_wait函数内部。

程序示例：

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

pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count = 0;

void *decrement_count(void *arg)
{
    pthread_mutex_lock(&count_lock);
    printf("decrement_count get count_lock\n");
    while(count == 0)
    {
        printf("decrement_count count == 0 \n");
        printf("decrement_count before cond_wait \n");
        pthread_cond_wait(&count_nonzero, &count_lock);
        printf("decrement_count after cond_wait \n");
        printf("decrement_count count = %d \n",count);
    }

    count = count + 1;
    pthread_mutex_unlock(&count_lock);
}

void *increment_count(void *arg)
{
    pthread_mutex_lock(&count_lock);
    printf("increment_count get count_lock \n");
    if(count == 0)
    {
        printf("increment_count before cond_signal \n");
        pthread_cond_signal(&count_nonzero);
        printf("increment_count after cond_signal \n");
    }

    count = count + 1;
    printf("huangcheng \n");
    printf("increment_count count = %d \n",count);
    pthread_mutex_unlock(&count_lock);
}

int main(void)
{
    pthread_t tid1, tid2;

    pthread_mutex_init(&count_lock, NULL);
    pthread_cond_init(&count_nonzero, NULL);

    pthread_create(&tid1, NULL, decrement_count, NULL);
    sleep(2);
    pthread_create(&tid2, NULL, increment_count, NULL);

    sleep(10);
    pthread_exit(0);

    return 0;
}

运行结果：

# gcc -o pthread_cond pthread_cond.c -lpthread
#./pthread_cond
decrement_count get count_lock
decrement_count count == 0
decrement_count before cond_wait
increment_count get count_lock
increment_count before cond_signal
increment_count after cond_signal
huangcheng
increment_count count = 1
decrement_count after cond_wait
decrement_count count = 1

多线程编程,条件变量pthread_cond_t应用

程序代码：

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

pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;

void *decrement_counter(void *argv);
void *increment_counter(void *argv);

int main(int argc, char **argv)
{
    printf("counter: %d/n", counter);
    pthread_t thd1, thd2;
    int ret;

    ret = pthread_create(&thd1, NULL, decrement_counter, NULL);
    if(ret){
        perror("del:/n");
        return 1;
    }

    ret = pthread_create(&thd2, NULL, increment_counter, NULL);
    if(ret){
        perror("inc: /n");
        return 1;
    }

    int counter = 0;
    while(counter != 10){
        printf("counter: %d/n", counter);
        sleep(1);
        counter++;
    }

    return 0;
}

void *decrement_counter(void *argv)
{
    pthread_mutex_lock(&counter_lock);
    while(counter == 0)
        pthread_cond_wait(&counter_nonzero, &counter_lock);

    counter--;
    pthread_mutex_unlock(&counter_lock);

    return &estatus;
}

void *increment_counter(void *argv)
{
    pthread_mutex_lock(&counter_lock);
    if(counter == 0)
        pthread_cond_signal(&counter_nonzero);

    counter++;
    pthread_mutex_unlock(&counter_lock);

    return &estatus;
}

运行结果：
#gcc -o pthread_cond2 pthread_cond2.c -lpthread
#./pthread_cond2
counter: 0
counter: 0
counter: 1
counter: 2
counter: 3
counter: 4
counter: 5
counter: 6
counter: 7
counter: 8
counter: 9

调试程序的运行过程：

1、开始时 counter 为0 （main）

2、ret = pthread_create(&thrd1, NULL, decrement_counter, NULL)处生成一个thrd1线程运行decrement_counter(),

此线程内函数运行流程为:

先锁定 互斥锁（count_lock）如果counter为0,此线程被阻塞在条件变量（count_nonzero）上.同时释放互斥锁count_lock（wait内部会先释放锁，等待signal激活后自动再加上锁）.

3、与此同时主程序还在运行,创建另一个线程thrd2运行 increment_counter,

此线程内的函数流程如下:

先锁定 互斥锁（count_lock）【wait内部释放锁的互斥锁】如果counter为0, 唤醒在条件变量（count_nonzero）上的线程即thrd1.但是由于有互斥锁count_lock【signal激活后，wait内部又自动加上锁了】, thrd1还是在等待. 然后count++,释放互斥锁,.......thrd1由于互斥锁释放,重新判断counter是不是为0,如果为0再把线程阻塞在条件变量count_nonzero上,但这时counter已经为1了.所以线程继续运行.counter--释放互斥锁......（退出后，运行主线程main）

4、与此主程序间隔打印counter运行一段时间退出.

注：更清晰的运行流程请详见如下“改进代码”

后记,在编译的时候加上 -lpthread

改进代码：

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

pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;

void *decrement_counter(void *argv);
void *increment_counter(void *argv);

int main(int argc, char **argv)
{
    printf("counter: %d/n", counter);
    pthread_t thd1, thd2;
    int ret;

    ret = pthread_create(&thd1, NULL, decrement_counter, NULL);
    if(ret){
        perror("del:/n");
        return 1;
    }

    ret = pthread_create(&thd2, NULL, increment_counter, NULL);
    if(ret){
        perror("inc: /n");
        return 1;
    }

    int counter = 0;
    while(counter != 10){
        printf("counter(main): %d/n", counter);
        sleep(1);
        counter++;
    }

    return 0;
}

void *decrement_counter(void *argv)
{
    printf("counter(decrement): %d/n", counter);
    pthread_mutex_lock(&counter_lock);
    while(counter == 0)
        pthread_cond_wait(&counter_nonzero, &counter_lock); //进入阻塞(wait)，等待激活(signal)
    
    printf("counter--(before): %d/n", counter);    
    counter--; //等待signal激活后再执行
    printf("counter--(after): %d/n", counter);    
    pthread_mutex_unlock(&counter_lock); 

    return &estatus;
}

void *increment_counter(void *argv)
{
    printf("counter(increment): %d/n", counter);
    pthread_mutex_lock(&counter_lock);
    if(counter == 0)
        pthread_cond_signal(&counter_nonzero); //激活(signal)阻塞(wait)的线程(先执行完signal线程，然后再执行wait线程)

    printf("counter++(before): %d/n", counter);    
    counter++; 
    printf("counter++(after): %d/n", counter);    
    pthread_mutex_unlock(&counter_lock);

    return &estatus;
}

运行结果：

# gcc -o pthread_cond2 pthread_cond2.c -lpthread
#./pthread_cond2
counter: 0
counter(main): 0
counter(decrement): 0
counter(increment): 0
counter++(before): 0
counter++(after): 1
counter--(before): 1
counter--(after): 0
counter(main): 1
counter(main): 2
counter(main): 3
counter(main): 4
counter(main): 5
counter(main): 6
counter(main): 7
counter(main): 8
counter(main): 9