Linux--多线程之如何使用条件变量

以你之姓@ 2022-11-27 03:14 143阅读 0赞

### Linux--多线程之如何使用条件变量 ###

*  条件变量
 *   *   *  初始化方法：
         *  条件变量等待
         *  条件变量通知
         *  demo
     *  运行效果

# 条件变量 #

条件变量的使用是为了让CPU节省资源，避免空转。条件达成线程才开始运行，不进行无用的等待。

*  注意：条件变量要配合互斥体进行操作
 *  对象：

pthread_cond_t  condtion ;

*  条件变量相关函数：

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int pthread_cond_destroy(pthread_cond_t *cond)；</td> 
   <td>销毁条件变量</td> 
  </tr> 
  <tr> 
   <td>int pthread_cond_init(pthread_cond_t * cond,const pthread_condattr_t * attr);</td> 
   <td>初始化条件变量</td> 
  </tr> 
  <tr> 
   <td>int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,const struct timespec *restrict abstime);</td> 
   <td>条件变量超时等待函数</td> 
  </tr> 
  <tr> 
   <td>int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);</td> 
   <td>条件变量阻塞等待函数</td> 
  </tr> 
  <tr> 
   <td>int pthread_cond_broadcast(pthread_cond_t *cond)</td> 
   <td>条件变量通知所有等待的线程</td> 
  </tr> 
  <tr> 
   <td>int pthread_cond_signal(pthread_cond_t *cond)</td> 
   <td>条件变量通知等待的一个线程</td> 
  </tr> 
 </tbody> 
</table>

*  注意：条件变量要配合互斥体进行操作

### 初始化方法： ###

#include <pthread.h>
    
    int pthread_cond_destroy(pthread_cond_t *cond);
    int pthread_cond_init(pthread_cond_t * cond,const pthread_condattr_t * attr);
    
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

参数：  
pthread\_cond\_t \*cond： 条件变量的对象地址  
const pthread\_condattr\_t \* attr：条件变量的属性，一般置空

### 条件变量等待 ###

等待条件变量 
    #include <pthread.h>
    
    int pthread_cond_timedwait(pthread_cond_t *restrict_cond,pthread_mutex_t *restrict_mutex,
    								const struct timespec *restrict_abstime);
    	int pthread_cond_wait(pthread_cond_t *restrict_cond,
    					pthread_mutex_t *restrict mutex);

参数：  
pthread\_cond\_t \*restrict\_cond： 条件变量的对象地址  
pthread\_mutex\_t \*restrict\_mutex:互斥锁  
struct timespec \*restrict\_abstime:条件变量等待的时间

### 条件变量通知 ###

通知条件变量
    #include <pthread.h>
    
    int pthread_cond_broadcast(pthread_cond_t *cond);
    int pthread_cond_signal(pthread_cond_t *cond);

参数：

pthread\_cond\_t \*cond：条件变更的对象地址

### demo ###

#include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include "pthread.h"
    
    #define BUFFER_SIZE 2
    
    /* Circular buffer of integers. */
    struct prodcons 
    { 
      int buffer[BUFFER_SIZE];      /* the actual data */    
      pthread_mutex_t lock;         /* mutex ensuring exclusive access to buffer */
      int readpos, writepos;        /* positions for reading and writing */
      pthread_cond_t notempty;      /* signaled when buffer is not empty */
      pthread_cond_t notfull;       /* signaled when buffer is not full */
    };
    
    /* Initialize a buffer */
    void init(struct prodcons *prod)
    { 
      pthread_mutex_init(&prod->lock,NULL); //初始化锁
      pthread_cond_init(&prod->notempty,NULL); //初始化条件变量（不空）
      pthread_cond_init(&prod->notfull,NULL); //初始化条件变量（不满）
      prod->readpos = 0;   //读取pos
      prod->writepos = 0;  //写入的pos
    }
    /* Store an integer in the buffer */
    void put(struct prodcons * prod, int data)
    { 
            pthread_mutex_lock(&prod->lock);  //上锁
            /* Wait until buffer is not full */
            while ((prod->writepos + 1) % BUFFER_SIZE == prod->readpos) 
    		{ 
                printf("producer wait for not full\n");
            	pthread_cond_wait(&prod->notfull, &prod->lock);
            }
     		 /* Write the data and advance write pointer */
            prod->buffer[prod->writepos] = data;
            prod->writepos++;
            if (prod->writepos >= BUFFER_SIZE) 
    			prod->writepos = 0;
      		/*Signal that the buffer is now not empty */
            pthread_cond_signal(&prod->notempty);  //通知不空的条件变量
            pthread_mutex_unlock(&prod->lock);  //解锁
    }
    /* Read and remove an integer from the buffer */
    int get(struct prodcons *prod)
    { 
            int data;
            pthread_mutex_lock(&prod->lock);  //上锁
            /* Wait until buffer is not empty */
            while (prod->writepos == prod->readpos) 
    		{ 
            	printf("consumer wait for not empty\n");
                pthread_cond_wait(&prod->notempty, &prod->lock);  //空了就等待不满条件变量写入数据
            }
            /* Read the data and advance read pointer */
            data = prod->buffer[prod->readpos];  //读取数据
            prod->readpos++;   
            if (prod->readpos >= BUFFER_SIZE) 
    			prod->readpos = 0;
            /* Signal that the buffer is now not full */
            pthread_cond_signal(&prod->notfull);  //通知不满条件变量读取完毕
            pthread_mutex_unlock(&prod->lock);  //解锁
            return data;
    }
    
    #define OVER (-1)
    struct prodcons buffer;
    /*--------------------------------------------------------*/
    void * producer(void * data)
    { 
    	int n;
    	for (n = 0; n < 5; n++) 
    	{ 
    		printf("producer sleep 1 second......\n");
    		sleep(1);
    		printf("put the %d product\n", n);
    		put(&buffer, n);  //生产者写入数据
    	}
    	for(n=5; n<10; n++)
    	{ 
    		printf("producer sleep 3 second......\n");
    		sleep(3);
    		printf("put the %d product\n",n);
    		put(&buffer,n);  //生产者写入数据
    	}
    	put(&buffer, OVER);   //生产-1表示停止生产
    	printf("producer stopped!\n");
    	return NULL;
    }
    /*--------------------------------------------------------*/
    void * consumer(void * data)
    { 
    	int d=0;
    	while (1) 
    	{ 
    		printf("consumer sleep 2 second......\n");
    		sleep(2);
    		d=get(&buffer);  //消费者读取数据
    		printf("get the %d product\n", d);
    // d = get(&buffer);
        	if (d == OVER ) break;
    	}
    	printf("consumer stopped!\n");
    	return NULL;
    }
    /*--------------------------------------------------------*/
    int main(int argc,char *argv[])
    { 
    	pthread_t th_a, th_b;  //创建两个线程ID a,b
    	void * retval;   //用来获取线程的退出码
    	init(&buffer);   //初始化锁和条件变量
    	pthread_create(&th_a, NULL, producer, 0);  //创建线程a
    	pthread_create(&th_b, NULL, consumer, 0);  //创建线程b
    	/* Wait until producer and consumer finish. */
        pthread_join(th_a, &retval);  //等待线程1结束
        pthread_join(th_b, &retval);  //等待线程2结束
        return 0;
    }

## 运行效果 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTMwOTkxNg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/dbe5e67ffa9e47019a3f9616b0531290.png