多线程中代替轮询

考虑一种情形：
有一个容器，里面时任务，只要容器不为空，那么就有很多个线程去处理里面的任务。
同时有一个线程专门向其中添加任务。

上面的这个情形存在2个问题（或者更多）：

1. 多线程中同步的问题
   所以需要使用互斥量
2. 如果添加元素慢，那么每个线程都将会不停的轮询这个容器是否为空。
   轮询是一种很耗费资源的行为。
   为了解决这个问题，引入条件变量。

一下代码将会导致轮询
我们假设i代表容器中有没有元素（实际中，这个存储任务的容器应该被封装在一个类中了。）。
step表示我们每10步想里面添加一个元素，而readtid函数每一步都会去请求元素。

#include <iostream>
#include <pthread.h>

int i=0;
pthread_mutex_t mutex;

void *readtid(void* arg)
{
    std::cout<<"start read"<<std::endl;
    while(true)
    {
        pthread_mutex_lock(&mutex);
        if(!i)
        {
            std::cout<<"not ready"<<std::endl;
        }else{
            std::cout<<"ready"<<std::endl;
            i=0;
        }
        pthread_mutex_unlock(&mutex);
    }
}

void *change(void *arg)
{
    int step = 0;
    while(true)
    {
        pthread_mutex_lock(&mutex);
        step++;
        if(step%10==0)
        {
            i=1;
        }
        pthread_mutex_unlock(&mutex);
    }
}

int main()
{
    pthread_t tid1,tid2;
    pthread_mutex_init(&mutex,NULL);

    pthread_create(&tid1,NULL,readtid,NULL);
    pthread_create(&tid1,NULL,change,NULL);

    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    return 0;
}

这里使用互斥量来同步。（如果不使用互斥量，那么不管歩数是多少，输出结果都是交叉的。应为编译器这个小婊子会优化）
输出结果为：

image.png

如果多个线程的话，资源消耗更加严重。

条件变量

这个东西的作用就是：
在调用处阻塞，知道别的线程给他发送一个信号，他才会继续执行。

如果应用在这个情景中：
readtid先读取一次，如果i为0 ,那么就阻塞该线程。
change中，改变i值以后，发送一个信号，唤醒正带等待的线程。
于是，readtid被唤醒，再次执行。

pthread_con_t t;    //条件变量
pthread_con_int(pthread_con_t *);  //初始化条件变量
pthread_con_wait(pthread_con_t * , pthread_metux_t *); //指定要等待的条件变量
pthread_con_timedwait(pthread_con_t *, pthread_mutex_t *,struc timespec *);//设置等待超时
pthread_con_signal(pthread_con_t *); //唤醒一个等待指定条件变量的线程
pthread_cond_broadcast(pthread_con_t *);//唤醒所有的等待线程
pthread_con_destroy(pthread_con_t *);//销毁条件变量

前两个函数不讲了。声明和创建。

第三个函数：

1. 第一个参数指定，能够被唤醒的条件变量。
   就好比说，我要睡觉了，如果小姐姐不来，就别叫醒我。而第五个函数就会发送信号：可能是小姐姐来了，也可能是别的事情，只有第五个函数发送的是小姐姐来的时候，第三个函数才由阻塞变为非阻塞。也就是指定一个要等待的条件变量。
2. 第二个参数：与指定条件变量相关联的锁，这个锁需要人为记住。

这个函数了解这些就够了，具体以后再补。同时第四个参数也跳过不讲。

第五个函数：
当改变一个容器（或者一个容器准备好了的时候），然后调用该函数，发送指定的条件变量。
让等待该条件变量的线程唤醒。让处理这个容器的线程开始执行。

这里是这样的：

1. 一个程序中可能存在多个条件变量，那么在唤醒线程的时候就需要唤醒那些等待某个特定条件变量的线程，而不是全部唤醒。所以需要在第三个函数中指定要等待的条件变量。第五个参数中要指定唤醒特定的线程。这都是通过条件变量作为桥梁的。
2. 等待条件变量的可能有多个线程。但是第五个函数，只会唤醒一个线程。
   如果没有线程可以唤醒，那么也不会报错。

使用条件变量，下面的代码改为：

#include <iostream>
#include <pthread.h>
#include <vector>
#include <unistd.h>

std::vector<int> intV;
pthread_mutex_t mutex;
pthread_cond_t con;

void *readtid(void* arg)
{
    std::cout<<"start read"<<std::endl;
    while(1)
    {
        pthread_mutex_lock(&mutex);
//      std::cout<<"vector size() : "<<intV.size()<<std::endl;
        if(!intV.size())
        {
            std::cout<<"not ready"<<std::endl;
            pthread_cond_wait(&con,&mutex);
        }else{
            std::cout<<"ready"<<std::endl;
            intV.pop_back();
        }
        pthread_mutex_unlock(&mutex);
    }
}

void *change(void *arg)
{
    for(int c=1;c<400;c++)
    {
        pthread_mutex_lock(&mutex);
        if(c%4==0)
        {
            intV.push_back(1);
            pthread_cond_signal(&con);
            sleep(2);      //这里等待以下。效果明显
        }

        pthread_mutex_unlock(&mutex);
    }
}

int main()
{
    pthread_t tid1,tid2;

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

    pthread_create(&tid1,NULL,readtid,NULL);
    pthread_create(&tid1,NULL,change,NULL);

    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    return 0;

}

image.png

】

总结

条件变量用来避免轮询。