Day57 Linux 条件变量 信息量

目录

1. 条件变量

1.1主要应用函数

 1.2生产-消费者模型

2. 信号量

 

---

1. 条件变量

条件变量本身不是锁 ! 但它也可以造成线程阻塞。

通常与互斥锁配合使用。给多线程提供一个会合的场所。

1.1主要应用函数

pthread_cond_t 类型用于定义条件变量。

pthread_cond_t cond;

pthread_cond_init 函数  

int pthread_cond_init ( pthread_cond_t * restrict cond ,

                                  const pthread_condattr * restrict attr );

参 1 ：需要初始化的条件变量

参 2 : attr 表条件变量属性，通常为默认值，传 NULL 即可

初始化有两种方法：

1. 动态初始化： pthread_cond_init （ & cond ， NULL ）

2. 静态初始化： pthread_cond_t cond = PTHREAD_COND_INITIALIZER ; 

pthread_cond_wait 函数

阻塞等待一一个条件变量

int pthread_cond_wait ( pthread_cond_t * restrict cond ,

                                        pthread_mutex_t * restrict mutex );

参 1 ：已经初始化号的条件变量，如果条件不满足，则一直阻塞等待

参 2 ：一把已加锁的互斥锁，解锁已加锁的 mutex ，等价 pthread_mutex_unlock ( & mutex )

        参1 、参 2 执行时是原子操作。（也就阻塞时，会继续操作解锁，中途不会被中断）

函数返回 return 前：

        当条件变量必须满足，同步解除阻塞并重新给互斥量加pthread_mutex_lock ( & mutex )

 

pthread_cond_signal函数

唤醒等待在该条件变量上的一个线程

pthread_cond_broadcast函数

唤醒等待在该条件变量上的所有线程

int pthread_cond_signal ( & cond );

参 1 ：已经初始化好的条件变量

 1.2生产-消费者模型

例程：生产-消费者模型代码

#include 
#include 
#include 
#include 
#include 
/*链表作为公享数据,需被互斥量保护*/
 
#define SIZE 100
 
int repository[SIZE]={0};//定义仓库大小，并初始化为0
 
/*静态初始化一个条件变量和一个互斥量*/
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
int empty_repository(int arr[])
{
    int i,sum=0;
    for(i=0;i
    {
        sum += arr[i];
    }
    return sum;
}
 
int fill_repository(int arr[])
{
    int i,sum;
    for(i=0;i
    {
        if(arr[i]==0)
        {
            arr[i]= rand() % 1000 + 1;
            printf("-------fill a[%d]=%d\n",i,arr[i]);
            return arr[i];
        }
    }
    return -1;
}
 
int del_repository(int arr[])
{
    int i,temp;
    for(i=SIZE;i>=0;i--)
    {
        if(arr[i]!=0)
        {
            temp=arr[i];
            printf("-------del a[%d]=%d\n",i,arr[i]);
            arr[i]= 0;
            return temp;
        }
    }
return -1;
}
 
void *consumer(void *p)
{
    for (;;)
    {
        int ret=pthread_mutex_lock(&lock);
        if(ret !=0)
        {
            printf("consumer mutex_lock err:%s\n",strerror(ret));
        }
        while (!empty_repository(repository))
        {
//如果条件不满足，释放锁，并阻塞在此处
//如果条件满足，重新加锁，并解除阻塞，进行循环条件判断
        printf("cond_wait test mask\n");
        pthread_cond_wait(&has_product, &lock);
        }
    //模拟消费掉一个产品
        ret=del_repository(repository);
        if(ret==-1)
        {
            printf("del_repository() err\n");
            pthread_exit(NULL);
        }
        pthread_mutex_unlock(&lock);
        printf("-Consume %lu---Produce id=%d\n", pthread_self(), ret);
 
        sleep(rand() % 5);
    }
}
 
void *producer(void *p)
{
    for (; ;)
    { //sleep(5)，为验证consumer线程中的，pthread_cond_wait()会进行解锁+阻塞功能
        sleep(5);
        //生产者拿锁成功，再生产产品
        int ret=pthread_mutex_lock(&lock);
        if(ret !=0)
        {
            printf("producer mutex_lock() err:%s\n",strerror(ret));
            pthread_mutex_unlock(&lock);
            break;//跳出循环
    }
    //模拟生产一个产品
        ret=fill_repository(repository);
        if(ret==-1)
        {
            printf("fill_repository() err\n");
            pthread_mutex_unlock(&lock);
            break;
// pthread_exit(NULL);//生产仓库满后，无法继续生产，退出生产线程
        }
        pthread_mutex_unlock(&lock);
        printf("-producer %lu---Produce id=%d\n", pthread_self(), ret);
        pthread_cond_signal(&has_product); //条件满足了，通知等待条件变量has_product的线程
        usleep(100000);
    }
}
 
int main(int argc, char *argv[])
{
    pthread_t tid01, tid02,tid03;
    srand(time(NULL));
    pthread_create(&tid01, NULL, producer, NULL);
    pthread_create(&tid02, NULL, consumer, NULL);
    // pthread_create(&tid03, NULL, consumer, NULL);
    pthread_join(tid01, NULL);
    pthread_join(tid02, NULL);
    // pthread_join(tid03, NULL);
 
    return 0;
}

2. 信号量

信号量，是相对折中的一 - 种处理方式，既能保证同步，数据不混乱，又能提高线程并发。

 int sen_destroy(sem_t *sem);

int sem_wait ( sen_t * sem );

sem_timedwait 函数

限时尝试对信号量加锁

int sem_timedwait ( sem_t * sem , const struct timespec * abs_timeout );

参 2 : abs_timeout 采用的是绝对时间（ 1970 年 1 月 1 日 0 时 0 分 0 秒）。

比如定时 1 秒 :

time_t cur = time ( NULL ); 获取当前时间

struct timespec t ; 定义 timespec 结构体变量 t

t . tv_sec = cur + 1 ; 定时 1 秒。

t . tv_nsec = t . tv_sec + 100 ;

sem_timedwait ( & sem , & t ); 传参