POSIX线程库条件变量的使用——Pthreads线程库实例笔记4

条件变量（Condition Variables）

条件变量是什么？

• 条件变量为我们提供了另一种线程间同步的方法，然而，互斥量是通过控制线程访问数据来实现同步，条件变量允许线程同步是基于实际数据的值。
• 如果没有条件变量，程序员需要让线程不断地轮询，以检查是否满足条件。由于线程处在一个不间断的忙碌状态，所以这是相当耗资源的。条件变量就是这么一个不需要轮询就可以解决这个问题的方法。
• 条件变量总是跟互斥锁（mutex lock）一起使用。
• 下面是使用条件变量的比较典型的过程：

主线程 声明并初始化需要同步的全局数据或变量（例如”count“） 声明并初始化一个条件变量对象 声明并初始化一个与条件变量关联的互斥量 创建线程A和B并开始运行
线程A 线程运转至某一个条件被触发（例如,”count“必须达到某个值） 锁定相关联的互斥量并检查全局变量的值 调用pthread_con_wait()阻塞线程等待线程B的信号。请注意，调用pthread_con_wait()以自动的原子方式(atomically)解锁相关联的互斥量，以便于可以被线程B使用。 当收到信号时，唤醒线程。互斥量被以自动的原子方式被锁定。 明确的解锁互斥量。 继续	Thread B 线程运转 锁定相关联的互斥量 更改线程A正在等待的全局变量的值 检查线程A等待的变量值，如果满足条件，发信号给线程A 解锁互斥量 继续
主线程 Join / Continue

 

 

创建和销毁条件变量

函数：

pthread_cond_init (condition,attr)

pthread_cond_destroy (condition)

pthread_condattr_init (attr)

pthread_condattr_destroy (attr)

用法：

• 条件变量必须声明为pthread_cond_t类型，并且在使用前必须要初始化。初始化，有两种方法：

1. 静态初始化，像这样声明：pthread_con_t myconvar = PTHREAD_CON_INITIALIZER；
2. 动态初始化，使用pthread_cond_init()函数。用创建条件变量的ID作为件参数传给线程，这种方法允许设置条件变量对象属性attr。

• 可设置的attr对象经常用来设置条件变量的属性，条件变量只有一种属性：process-thread，它的作用是允许条件变量被其它进程的线程看到。如果使用属性对象，必须是pthread_condattr_t类型（也可以赋值为NULL，作为默认值）。

        注意，不是所有的实现都用得着process-shared属性。

• pthread_condattr_init()和pthread_condattr_destroy()函数是用来创建和销毁条件变量属性对象的。
• 当不再需要某条件变量时，可用pthread_cond_destroy()销毁。

 

条件变量的等待和信号发送

函数：

pthread_cond_wait (condition,mutex)

pthread_cond_signal (condition)

pthread_cond_broadcast (condition)

使用：

• pthread_cond_wait()阻塞调用线程，直到指定的条件变量收到信号。当互斥量被锁定时，应该调用这个函数，并且在等待时自动释放这个互斥量，在接收到信号后线程被唤醒，线程的互斥量会被自动锁定,程序员在线程中应当在此函数后解锁互斥量。
• pthread_cond_signal()函数常用来发信号给（或唤醒）正在等待条件变量的另一个线程，在互斥量被锁定后应该调用这个函数，并且为了pthread_cond_wait()函数的完成必须要解锁互斥量。
• 如果多个线程处于阻塞等待状态，那么必须要使用pthreads_cond_broadcast()函数，而不是pthread_cond_signal()。
• 在调用pthread_cond_wait()函数之前调用pthread_cond_signal()函数是个逻辑上的错误，所以，在使用这些函数时，正确的锁定和解锁与条件变量相关的互斥量是非常必要的，例如：

1. 在调用pthread_cond_wait()之前锁定互斥量失败，可致使其无法阻塞；
2. 在调用pthread_cond_signal()之后解锁互斥量失败，则致使与之对应的pthread_cond_wait()函数无法完成，并仍保持阻塞状态。

 

实例分析

看到下面的一汪代码不要挠头，99行而已，之后会抽丝剥茧，目的是对条件变量的运行机制了解个大概：

 

/******************************************************************************
 * 描述：
 *     应用Pthreads条件变量的实例代码，主线程创建三个线程，其中两个为“count”变量做
 * 加法运算，第三个线程监视“count”的值。当“count”达到一个限定值，等待线程准备接收来
 * 自于两个加法线程中一个的信号，等待 线程唤醒后更改“count”的值。程序继续运行直到加法
 * 线程达到TCOUNT的值。最后，主程序打印出count的值。
 ******************************************************************************/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS  3
#define TCOUNT 5       //单线程轮询次数
#define COUNT_LIMIT 7  //发送信号的次数
int count = 0; //全局的累加量

pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;

void *inc_count(void *t) {
    int i;
    long my_id = (long) t;

    for (i = 0; i < TCOUNT; i++) {
        pthread_mutex_lock(&count_mutex);
        count++;
        /*
         * 检查count的值，如果条件满足就发信号给等待线程
         * 注意，此处是用信号量锁定的。
         * */
        if (count < COUNT_LIMIT) {
            printf("inc_count(): thread %ld, count = %d  Threshold reached. ",
                    my_id, count);
            pthread_cond_signal(&count_threshold_cv);
            printf("Just sent signal.\n");
        }
        printf("inc_count(): thread %ld, count = %d, unlocking mutex\n", my_id,
                count);
        pthread_mutex_unlock(&count_mutex);

        /*为线程轮询互斥锁增加延时*/
        sleep(1);
    }
    pthread_exit(NULL);
}

void *watch_count(void *t) {
    long my_id = (long) t;
    printf("Starting watch_count(): thread %ld\n", my_id);

    /*锁定互斥量并等待信号，注意，pthread_cond_wait函数在等待时将自动以自动原子方式
     * 解锁互斥量。还有，请注意，如果等待线程运行到等待函数之前已经满足COUNT_LIMIT的
     * 条件判断，轮询会忽略掉等待函数，
     * */
    while (count < COUNT_LIMIT) {
        pthread_mutex_lock(&count_mutex);
        printf("watch_count(): thread %ld going into wait...\n", my_id);
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        printf("watch_count(): thread %ld Condition signal received.\n", my_id);

        printf("watch_count(): thread %ld count now = %d.\n", my_id, count);
        pthread_mutex_unlock(&count_mutex);
    }
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
    int i;
    long t1 = 1, t2 = 2, t3 = 3;
    pthread_t threads[3];
    pthread_attr_t attr;

    /*初始化互斥量和条件变量对象*/
    pthread_mutex_init(&count_mutex, NULL);
    pthread_cond_init(&count_threshold_cv, NULL);

    /*创建线程时设为可连接状态，便于移植*/
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&threads[0], &attr, watch_count, (void *) t1);
    pthread_create(&threads[1], &attr, inc_count, (void *) t2);
    pthread_create(&threads[2], &attr, inc_count, (void *) t3);

    /* 等待所有线程完成*/
    for (i = 1; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
   /*发送信号给监听线程*/
    pthread_cond_signal(&count_threshold_cv); 
    pthread_join(threads[0],NULL);
    printf("Main(): Waited on %d threads. Final value of count = %d. Done.\n",
            NUM_THREADS, count);

    /*清除并退出 */
    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&count_mutex);
    pthread_cond_destroy(&count_threshold_cv);
    pthread_exit(NULL);
}

 

• 主线程创建了3个子线程，一个线程用来监听信号（threads[0]，调用watch_count()函数），两个线程用来发送信号（threads[1]、threads[2]，调用inc_count()函数）；

• 两个发送信号线程，主要负责两件事：

1. 两个线程利用互斥量为count做加法运算，两个线程一起做了（2*TCOUNT=）10次运算；
2. count值小于COUNT_LIMIT时，发送信号给监听线程；

• 监听线程作用只有一个，就是如果count值小于COUNT_LIMIT则等待线程；
• 整体来讲，就是两个发送信号的线程让count做迭加运算，并在迭加到一定值之前给监听线程发送信号，监听线程收到打印信息
• 两个地方需要注意一下：
  1. pthread_cond_wait()有解锁和锁定互斥量的操作，它所进行的操作大体有三步：解锁—阻塞监听—锁定，所以在监听线程的循环体里面有两次“锁定-解锁”的操作；
  2. 主函数main最后的pthread_cond_signal()这句必不可少，因为监听线程运转没有延时，在count的值达到COUNT_LIMIT-1时，已经处于waiting状态。 

# Pthreads 
Starting watch_count(): thread 1
watch_count(): thread 1 going into wait...
inc_count(): thread 2, count = 1  Threshold reached. Just sent signal.
inc_count(): thread 2, count = 1, unlocking mutex
watch_count(): thread 1 Condition signal received.
watch_count(): thread 1 count now = 1.
watch_count(): thread 1 going into wait...
inc_count(): thread 3, count = 2  Threshold reached. Just sent signal.
inc_count(): thread 3, count = 2, unlocking mutex
watch_count(): thread 1 Condition signal received.
watch_count(): thread 1 count now = 2.
watch_count(): thread 1 going into wait...
inc_count(): thread 2, count = 3  Threshold reached. Just sent signal.
inc_count(): thread 2, count = 3, unlocking mutex
watch_count(): thread 1 Condition signal received.
watch_count(): thread 1 count now = 3.
watch_count(): thread 1 going into wait...
inc_count(): thread 3, count = 4  Threshold reached. Just sent signal.
inc_count(): thread 3, count = 4, unlocking mutex
watch_count(): thread 1 Condition signal received.
watch_count(): thread 1 count now = 4.
watch_count(): thread 1 going into wait...
inc_count(): thread 2, count = 5  Threshold reached. Just sent signal.
inc_count(): thread 2, count = 5, unlocking mutex
watch_count(): thread 1 Condition signal received.
watch_count(): thread 1 count now = 5.
watch_count(): thread 1 going into wait...
inc_count(): thread 3, count = 6  Threshold reached. Just sent signal.
inc_count(): thread 3, count = 6, unlocking mutex
watch_count(): thread 1 Condition signal received.
watch_count(): thread 1 count now = 6.
watch_count(): thread 1 going into wait...
inc_count(): thread 2, count = 7, unlocking mutex
inc_count(): thread 3, count = 8, unlocking mutex
inc_count(): thread 2, count = 9, unlocking mutex
inc_count(): thread 3, count = 10, unlocking mutex
watch_count(): thread 1 Condition signal received.
watch_count(): thread 1 count now = 10.
Main(): Waited on 3 threads. Final value of count = 10. Done.