Linux 线程 （第三阶段 条件控制）

7.线程条件控制实现线程的同步

学习线程可参考的博文：https://www.cnblogs.com/xiehongfeng100/p/4620852.html
条件变量相关API

• 条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。
• 条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。
• 条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。
  1. 创建及销毁条件变量

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);
// 返回：若成功返回0，否则返回错误编号

除非需要创建一个非默认属性的条件变量，否则pthread_cont_init函数的attr参数可以设置为NULL。

2. 等待

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, cond struct timespec *restrict timeout);
// 返回：若成功返回0，否则返回错误编号

pthread_cond_wait等待条件变为真。如果在给定的时间内条件不能满足，那么会生成一个代表一个出错码的返回变量。传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作都是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。

pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数类似，只是多了一个timeout。timeout指定了等待的时间，它是通过timespec结构指定。

3. 触发

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
// 返回：若成功返回0，否则返回错误编号

这两个函数可以用于通知线程条件已经满足。pthread_cond_signal函数将唤醒等待该条件的某个线程，而pthread_cond_broadcast函数将唤醒等待该条件的所有进程。

注意一定要在改变条件状态以后再给线程发信号。

这里写一个代码（demo8.c），线程t1等待线程t2的条件触发，然后线程t1把这g_data=0;即让线程t2下一次可以继续操作全局变量g_data当操作到某个程度（g_data=3）的时候就触发线程t1条件让他往下走；如此往复。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;

pthread_mutex_t mutex;
pthread_cond_t cond;

void *func1(void *arg)//线程t1
{
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
		static int cnt = 0;
        while(1){
                pthread_cond_wait(&cond,&mutex);//等待线程t2的触发
                printf("t1 run===========================\n");
				
                printf("t1: %d\n",g_data);
                g_data = 0;
                sleep(1);
                if(cnt++ == 10){//运行10次线程t1会退出这个进程
                        exit(1);
                }

        }
}

void *func2(void *arg)//线程t2
{
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

        while(1){

                printf("t2: %d\n",g_data);
                pthread_mutex_lock(&mutex);
                g_data++;					//作为一个达到一定值触发线程t1，需要作为共享资源被锁包含住。
                if(g_data == 3){
                        pthread_cond_signal(&cond);//触发线程t1的等待
                }
                pthread_mutex_unlock(&mutex);//解锁放在睡眠的前面
                sleep(1);
        }
}

int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;

        pthread_mutex_init(&mutex,NULL);
        pthread_cond_init(&cond,NULL);

        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0){
        //      printf("main:create t1 success\n");
        }

        ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0){
        //      printf("main:create t2 success\n");
        }

//      printf("main:%ld\n",(unsigned long)pthread_self());

        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);

        return 0;
}

下图是以上程序运行的结果：（线程t2对全局变量的操作，然后达到条件，让线程t1被阻塞的等待通了，线程t1继续运行，然后线程t2休眠后继续操作全局变量，就像下图一样的场景）

这里写个测试的代码：
1、写测试的代码（testThread.c）

#include <stdlib.h>

int main(int argc,char**argv)
{
        int time = atoi(argv[1]);
        int i = 0;

        for(i=0; i<time;i++){
                system("./demo8");
        }
}

2、然后运行把结果都追加（>>）到test.ret.txt里面，指令如图：（&是让器在后台运行，我们可以操作终端）

上图的3994是这个进程的pid。

3、打开test.ret.txt，运行结果都存在这里面，如图：

这里还可以用宏来初始化锁和条件（用宏是静态初始化，用函数创建是动态初始化）代码（demo9.c）如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//用宏来静态初始化互斥量（锁）
pthread_cond_t cond = PTHREAD_MUTEX_INITIALIZER;//用宏来静态初始化条件变量

void *func1(void *arg)
{
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
        static int cnt = 0;

        while(1){

                pthread_cond_wait(&cond,&mutex);
                printf("t1 run===========================\n");

                printf("t1: %d\n",g_data);
                g_data = 0;
                sleep(1);
                if(cnt++ == 10){
                        exit(1);
                }
        }
}

void *func2(void *arg)
{
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

        while(1){

                printf("t2: %d\n",g_data);
                pthread_mutex_lock(&mutex);
                g_data++;
                if(g_data == 3){
                        pthread_cond_signal(&cond);
                }
                pthread_mutex_unlock(&mutex);
                sleep(1);
        }
}

int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;

//      pthread_mutex_init(&mutex,NULL);  把动态初始化注释了
//      pthread_cond_init(&cond,NULL);	  把动态初始化注释了

        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0){
        //      printf("main:create t1 success\n");
        }

        ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0){
        //      printf("main:create t2 success\n");
        }

//      printf("main:%ld\n",(unsigned long)pthread_self());

        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);

        return 0;
}
                                                                                

运行结果如下图（和demo8.c没差别）：

强化这块内容需要去看生产者与消费者的案例。