Linux线程（条件）

条件变量

1.条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。

2.条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。

3.条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。

条件变量（同步）

与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直 到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

  条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步 的一种机制，主要包括两个动作：

一个线程等待"条件变量的条件成立"而挂起；

另一个线程使 “条件成立”（给出条件成立信号）。

【原理】：

  条件的检测是在互斥锁的保护下进行的。线程在改变条件状态之前必须首先锁住互斥量。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量 可以被用来实现这两进程间的线程同步。

【条件变量的操作流程如下】：

1. 初始化：init()或者pthread_cond_tcond=PTHREAD_COND_INITIALIER；属性置为NULL；
2. 等待条件成立：pthread_wait，pthread_timewait.wait()释放锁,并阻塞等待条件变量为真 timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)；
3. 激活条件变量：pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)
4. 清除条件变量：destroy;无线程等待,否则返回EBUSY清除条件变量:destroy;无线程等待,否则返回EBUSY

// 初始化条件变量
int pthread_cond_init(pthread_cond_t *cond,
						pthread_condattr_t *cond_attr);
// 阻塞等待
int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);
// 超时等待
int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,
						const timespec *abstime);
// 解除所有线程的阻塞
int pthread_cond_destroy(pthread_cond_t *cond);
// 至少唤醒一个等待该条件的线程
int pthread_cond_signal(pthread_cond_t *cond);
// 唤醒等待该条件的所有线程
int pthread_cond_broadcast(pthread_cond_t *cond);<br /><br />

1. 创建及销毁条件变量

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. 等待

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. 触发

int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
// 返回：若成功返回0，否则返回错误编号

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

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

#include <pthread.h>

int g_data=0;
pthread_mutex_t mutex;
pthread_cond_t cond;

void *func(void *arg)
{
        printf("t1:%ld is create successfully!\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));

        while(1)
        {
                pthread_cond_wait(&cond,&mutex);
                printf("t1:data=%d\n",g_data);
                printf("t1 runs===============================\n");
                g_data=0;
                sleep(1);
        }
}

void *func2(void *arg1)
{
        printf("t2:%ld is create successfully!\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg1));
        while(1)
        {
                printf("t2:data=%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 ret2;
        int param=100;
        pthread_t t1;
        pthread_t t2;

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

//      int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
        ret=pthread_create(&t1,NULL,func,(void *)&param);
        if(ret==0)
        {
//              printf("main:create t1 succussfully!\n");
        }

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

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

/*      while(1)
        {
                printf("main:data=%d\n",g_data);
                sleep(1);
        }
*/
        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

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

        return 0;
}

补充

对于互斥锁与条件变量的初始化，也可以用静态初始化即使用宏,如：

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER
pthread_cond_t cond=PTHREAD_COND_INITIALIZER

什么是生产者和消费者？

在之前提供的示例代码中，生产者和消费者是两个不同的线程函数，它们分别用于生产数据和消费数据，模拟生产者-消费者问题。

生产者函数

在生产者函数中，线程会循环执行，生产一系列数据并放入共享缓冲区。在生产数据之前，生产者线程会对互斥锁进行上锁，以确保在生产数据时其他线程无法访问共享缓冲区。如果缓冲区已满（即 count == BUFFER_SIZE），生产者线程会调用 pthread_cond_wait 函数等待条件变量 cond_full 条件满足（即缓冲区不满）的通知。在生产完数据后，生产者线程会调用 pthread_cond_signal 函数通知消费者线程，可以进行消费操作。然后，生产者线程解锁互斥锁，允许其他线程访问共享缓冲区。

消费者函数：

在消费者函数中，线程也会循环执行，从共享缓冲区中取出数据并进行消费。在消费数据之前，消费者线程会对互斥锁进行上锁，以确保在消费数据时其他线程无法访问共享缓冲区。如果缓冲区为空（即 count == 0），消费者线程会调用 pthread_cond_wait 函数等待条件变量 cond_empty 条件满足（即缓冲区不空）的通知。在消费完数据后，消费者线程会调用 pthread_cond_signal 函数通知生产者线程，可以进行生产操作。然后，消费者线程解锁互斥锁，允许其他线程访问共享缓冲区。

通过这种方式，生产者和消费者线程之间实现了协调，避免了缓冲区溢出或空时的数据竞争问题，保证了线程之间的正确同步。