Linux 线程 —— 条件变量与信号量

Outside_

已于 2022-08-30 16:20:39 修改

阅读量310

点赞数 1

文章标签：链表 linux

于 2022-08-30 16:20:16 首次发布

本文链接：https://blog.csdn.net/Outside_/article/details/126600100

版权

1.5 使用条件变量实现生产者，消费者模型

1. 条件变量

条件变量作用：

阻塞线程
不是什么时候都能阻塞线程

链表头节点 
Node*head = NULL;
while(head == NULL)
{
  //我们想让代码在这个位置阻塞
  //等待链表中有了节点之后再继续向下运行
  //使用到了后面要讲的条件变量‐阻塞线程
}
//链表不为空的处理代码
xxxx

1.1 条件变量说明

不是锁，但是条件变量能够阻塞线程

使用条件变量+互斥量

互斥量：保护一块共享数据
条件变量：引起阻塞

例子：生产者和消费者模型

1.2 条件变量的两个动作

条件不满足，阻塞线程
当条件满足，通知阻塞的线程开始工作

1.3 条件变量的类型

pthread_cond_t cond ;

1.4 主要函数

初始化一个条件变量
    pthread_cond_init(pthread_cond_t * restrict cond,
    const pthread_condattr_t * restrict attr);

销毁一个条件变量
    pthread_cond_destroy(pthread_cond_t * cond);

阻塞等待一个条件变量
    pthread_cond_wait(pthread_cond_t *restrict cond,
    pthread_mutex_t * restrict mutex)；

    阻塞线程
    将已经上锁的mutex解锁
    该函数解除阻塞，对互斥锁加锁

限时等待一个条件变量
    pthread_cond_timedwait(pthread_cond_t * restrict cond,
    pthread_mutex_t * restrict mutex,
    const struct timespec * restrict abstime)；

唤醒至少一个阻塞在条件变量上的线程
    pthread_cond_signal(pthread_cond_t* cond);

唤醒全部阻塞在条件变量上的线程
    pthread_cond_broadcast(pthread_cond_t * cond)；

1.5 使用条件变量实现生产者，消费者模型

代码示例 pthread_cond.c

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

typedef struct node
{
	int data;
	struct node *next;
} Node;

Node *head = NULL;	   // create head node
pthread_mutex_t mutex; // create mutex
pthread_cond_t cond;   // create cond

// 生产者
void *producer(void *arg)
{
	while (1)
	{
		Node *pnew = (Node *)malloc(sizeof(Node)); // create node
		pnew->data = rand() % 500;				   // 给 data 赋值 500 内的随机数

		pthread_mutex_lock(&mutex); // lock

		// 头插法插入链表
		pnew->next = head;
		head = pnew;
		printf("produce: %ld, %d\n", pthread_self(), pnew->data);

		pthread_mutex_unlock(&mutex); // unlock
		pthread_cond_signal(&cond);	  // 通知消费者消费
		sleep(rand() % 3);
		free(pnew); // 释放内存
	}
	return 0;
}

// 消费者
void *customer(void *arg)
{
	while (1)
	{
		Node *pdel = (Node *)malloc(sizeof(Node));
		pthread_mutex_lock(&mutex); // lock

		if (head == NULL)
		{
			pthread_cond_wait(&cond, &mutex); // 阻塞等待生产者的信号
		}

		// delete head node
		pdel = head;
		head = head->next;
		printf("customer: %ld, %d\n", pthread_self(), pdel->data);
		free(pdel); // 释放内存

		pthread_mutex_unlock(&mutex); // unlock
	}
	return 0;
}

int main()
{
	// 创建线程
	pthread_t p1, p2;
	pthread_create(&p1, NULL, producer, NULL);
	pthread_create(&p2, NULL, customer, NULL);

	// 初始化互斥锁和条件变量
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);

	// 等待线程结束
	pthread_join(p1, NULL);
	pthread_join(p2, NULL);

	// 销毁线程
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);
	return 0;
}

代码运行结果：

生产者生产一个节点，消费者就删除一个，没有发生数据混乱。

2. 信号量

2.1 头文件

#include <semaphore.h>

2.2 信号量类型

sem_t sem;
加强版的互斥锁

2.3 主要函数

初始化信号量
    sem_init(sem_t *sem,int pshared,unsigned int value);
    0-线程同步
    1-进程同步
    value-最多有几个线程操作共享数据

销毁信号量
    sem_destroy(sem_t *sem);

加锁
    sem_wait(sem_t *sem);
    调用一次相当于对sem做了一次 -- 操作
    如果sem值为0，线程会阻塞

尝试加锁
    sem_trywait(sem_t *sem);
    sem == 0；加锁失败，不阻塞

限时尝试加锁
    sem_timewait(sem_t *sem,xxxx);

解锁++
    sem_post(sem_t *sem);
    对sem做了++ 操作