【Linux C | 多线程编程】线程同步 | 信号量(无名信号量) 及其使用例子

😁博客主页😁:🚀https://blog.csdn.net/wkd_007🚀
🤑博客内容🤑:🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭
🤣本文内容🤣:🍭介绍 🍭
😎金句分享😎:🍭你不能选择最好的,但最好的会来选择你——泰戈尔🍭
⏰发布时间⏰:

本文未经允许,不得转发!!!


在这里插入图片描述

🎄一、概述

信号量是由E.W.Dijkstra为互斥和同步的高级管理提出的概念。它支持两种原子操作,一个是wait操作(减少信号量的值),另一个是post操作(增加信号量的值)。

一般来说, 信号量是和某种预先定义的资源相关联的。信号量元素的值,表示与之关联的资源的个数。内核会负责维护信号量的值,并确保其值不小于0。


✨1.1 二值信号量、计数信号量

信号量按照初始化的信号量值,可以分为使用二值信号量(binary semaphore)和计数信号量(counting semaphore)

  • 二值信号量:是使用最广泛的信号量。 对于这种信号量而言,它只有两种合法值:0和1,对应一个可用的资源。若当前有资源可用,则与之对应的二值信号量的值为1;若资源已被占用,则与之对应的二值信号量的值为0。
  • 计数信号量:资源个数超过1个的信号量。假设计数信号量初始化的信号量值为5,表示该信号量有6中合法值:0、1、2、3、4、5。当取值为0时,表示没有资源可用了;其他合法值则表示资源的剩余数量。

✨1.2 System V信号量、POSIX信号量

Linux系统中提供了两个信号量实现,一种是System V信号量,另一种是POSIX信号量,它们的作用是相同的,都是用于同步进程之间及线程之间的操作,以达到无冲突地访问共享资源的目的。

下面是System V信号量的相关接口函数:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
int semctl(int semid, int semnum, int cmd,/* union semun arg*/);
int semop(int semid, struct sembuf *sops, unsigned nsops);

POSIX信号量提供了两类: 有名信号量和无名信号量。
有名信号量由于其有名字, 多个不相干的进程可以通过名字来打开同一个信号量, 从而完成同步操作, 所以有名信号量的操作要方便一些, 适用范围也比无名信号量更广。
有名信号量的函数接口与无名信号量基本相同,就是初始化和销毁有区别,下面是有名信号量的初始化、销毁接口:

sem_t *sem_open(const char *name, int oflag);
sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);
sem_close(sem_p);
sem_unlink(sem_p);

而无名信号量,由于没有名字多用于线程之间,也是本文重点节点的信号量,下文都是所说的信号量,都特指这种用于多线程同步的无名信号量


在这里插入图片描述

🎄二、无名信号量

无名信号量, 又称为基于内存的信号量,由于其没有名字,没法通过open操作直接找到对应的信号量,所以很难直接用于没有关联的两个进程之间。无名信号量多用于线程之间的同步。因为线程会共享地址空间, 所以访问共同的无名信号量是很容易办到的事情。

✨2.1 初始化无名信号量 | sem_init

无名信号量的初始化是通过sem_init函数来完成的。

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
Link with -pthread.
  • 函数描述:初始化sem指针指向的无名信号量。
  • 函数参数:
    • sem:要初始化的无名信号量地址;
    • pshared:用于声明信号量是在线程间共享还是在进程间共享。0表示在线程间共享,非零值则表示信号量将在进程间共享。 要想在进程间共享,信号量必须位于共享内存区域内。
    • value:指定的信号量初始值。
  • 返回值:成功返回 0, 失败返回 -1 并设置errno。

✨2.2 销毁无名信号量 | sem_destroy

销毁无名信号量的接口定义如下:

#include <semaphore.h>
int sem_destroy(sem_t *sem);
  • 函数描述:销毁sem指针指向的无名信号量。必须是sem_init函数初始化过的。
  • 函数参数:
    • sem:要销毁的无名信号量地址;
  • 返回值:成功返回 0, 失败返回 -1 并设置errno。

✨2.3 等待信号量 | sem_wait

信号量总是和某种资源关联在一起,申请资源时,需要先调用sem_wait函数。函数原型如下:

#include <semaphore.h>
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
  • 函数描述:这三个函数都是用于等待信号量, 它会将信号量的值减1。如果函数正处于阻塞,被信号中断,则返回-1,并且置errno为EINTR。
    • sem_wait:若信号量值大于0, 那么sem_wait函数将信号量的值减1之后会立刻返回。否则sem_wait函数陷入阻塞,待信号量的值大于0之后,再执行减1操作,然后成功返回。
    • sem_trywait:若信号量值大于0,那么sem_trywait函数将信号量的值减1之后会立刻返回。否则sem_trywait立刻返回失败, 并置errnoEAGAIN
    • sem_timedwait:若信号量值大于0,那么sem_timedwait函数将信号量的值减1之后会立刻返回。否则sem_timedwait会等待一段时间,如果超过了等待时间,信号量的值仍为0,那么返回 -1,并置errnoETIMEOUT
  • 函数参数:
    • sem:要等待的无名信号量地址;
    • abs_timeout:是一个绝对时间,可以使用gettimeofday函数或clock_gettime函数获取当前时间,再加上想等待的时间,最后将相加的值转换成struct timespec类型传给 sem_timedwait
  • 返回值:成功返回 0, 失败返回 -1 并设置errno。

✨2.4 发布信号量 | sem_post

前面介绍了信号量申请资源时要调用的函数,这小节介绍归还资源时信号量调用的函数 sem_post ,函数原型如下:

#include <semaphore.h>
int sem_post(sem_t *sem);
  • 函数描述:用于发布信号量,表示已经完成了对资源使用,可以归还资源了。
    如果发布信号量之前, 信号量的值是0,并且已经有线程正等待在该信号量上,调用sem_post之后,会有一个线程被唤醒,被唤醒的线程会继续sem_wait函数的减1操作。 如果有多个线程正等待在信号量上,那么将无法确认哪个线程会被唤醒。
  • 函数参数:
    • sem:要发布的无名信号量地址;
  • 返回值:成功返回 0, 失败返回 -1 并设置errno。
    参数指向非法的信号量地址时,会置errno为EINVAL。
    当信号量的值超过上限(即超过INT_MAX)时,置errnoEOVERFLOW

✨2.5 获取信号量的值 | sem_getvalue

信号量的值可以通过 sem_getvalue 获取,函数原型如下:

#include <semaphore.h>
int sem_getvalue(sem_t *sem, int *sval);
  • 函数描述:sem_getvalue函数会返回当前信号量的值, 并将值写入sval指向的变量.
    如果值大于0,表示不需要等待;如果值为0,表示再申请资源时需要等待。这个值不会为负数,并且其返回的值可能已经过时了
  • 函数参数:
    • sem:要获取值的无名信号量地址;
    • sval:传出参数,用于存放信号量值的int型地址。
  • 返回值:成功返回 0, 失败返回 -1 并设置errno。

在这里插入图片描述

🎄三、二值信号量的使用例子

首先了解一下什么是临界区,所谓临界区, 是指同一时间只能容许一个线程进入的一系列操作。

二值信号量是最常用的信号量,在Linux多线程编程中,二值信号量主要有两种用法:一是可以像互斥量一样,对临界区加锁,防止多个线程并发进入临界区。二是可以像条件变量一样,在“生产者-消费者”模式的多个线程进行同步地访问共享资源。

✨3.1 信号量在临界区的使用

下面代码是使用信号量来加锁临界区,使多个线程不会并发地进入临界区操作。这个用法看起来很像互斥量。

// 10_sem_mutex.c
// gcc 10_sem_mutex.c -l pthread
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
int g_Count = 0;
sem_t g_sem;
void *func(void *arg)
{
	int i=0;
	for(i=0; i<10000000; i++)
	{
		sem_wait(&g_sem);
		g_Count++;
		sem_post(&g_sem);
	}
	return NULL;
}

int main()
{
	sem_init(&g_sem, 0, 1);
	// 创建4个线程
	pthread_t threadId[4];
	int i=0;
	for(i=0; i<4; i++)
	{
		pthread_create(&threadId[i], NULL, func, NULL);
	}

	for(i=0; i<4; i++)
	{
		pthread_join(threadId[i],NULL);
		printf("join threadId=%lx\n",threadId[i]);
	}
	printf("g_Count=%d\n",g_Count);
	
	sem_destroy(&g_sem);
	
	return 0;
}

运行结果如下,从结果看,也是发挥了锁住临界区的作用:
在这里插入图片描述


✨3.2 信号量在“生产者-消费者”模式的使用

下面代码是信号量在“生产者-消费者”模式的使用,一些线程等待信号量,在另一些线程发布信号量。代码是参考上篇文章介绍条件变量的示例代码修改的,感兴趣的去可以看看。

代码里也有使用到互斥量,因为存在多个线程访问共享资源的情况,虽然也可以使用另一个信号量来做互斥,但那样的代码看起来就很困难。

// 10_producer_consumer_sem.c
// gcc 10_producer_consumer_sem.c -lpthread
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <errno.h>
#include "linux_list.h"

#define  COMSUMER_NUM	2

typedef struct _product
{
	struct list_head list_node;
	int product_id;
}product_t;

struct list_head productList;// 头结点
pthread_mutex_t product_mutex = PTHREAD_MUTEX_INITIALIZER;	// productList 的互斥量
sem_t 			g_sem;

// 生产者线程,1秒生成一个产品放到链表
void *th_producer(void *arg)
{
	int id = 0;
	while(1)
	{
		product_t *pProduct = (product_t*)malloc(sizeof(product_t));
		pProduct->product_id = id++;
		
		pthread_mutex_lock(&product_mutex);
		list_add_tail(&pProduct->list_node, &productList);
		pthread_mutex_unlock(&product_mutex);
		sem_post(&g_sem);
		
		sleep(1);
	}
	
	return NULL;
}

// 消费者线程,1秒消耗掉一个产品
void *th_consumer(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&product_mutex);
		while(list_empty(&productList)) // 条件不满足
		{
			pthread_mutex_unlock(&product_mutex);
			sem_wait(&g_sem);
			pthread_mutex_lock(&product_mutex);
		}
		// 不为空,则取出一个
		product_t* pProduct = list_entry(productList.next, product_t, list_node);// 获取第一个节点
		printf("consumer[%d] get product id=%d\n", *((int*)arg), pProduct->product_id);
		list_del(productList.next); // 删除第一个节点
		free(pProduct);
		pthread_mutex_unlock(&product_mutex);
	}
	return NULL;
}

int main()
{
	INIT_LIST_HEAD(&productList);	// 初始化链表
	sem_init(&g_sem, 0, 1);			// 初始化信号量
	
	// 创建生产者线程
	pthread_t producer_thid;
	pthread_create(&producer_thid, NULL, th_producer, NULL);
	
	// 创建消费者线程
	pthread_t consumer_thid[COMSUMER_NUM];
	int i=0, num[COMSUMER_NUM]={0,};
	for(i=0; i<COMSUMER_NUM; i++)
	{
		num[i] = i;
		pthread_create(&consumer_thid[i], NULL, th_consumer, &num[i]);
	}
	
	// 等待线程
	pthread_join(producer_thid, NULL);
	for(i=0; i<COMSUMER_NUM; i++)
	{
		pthread_join(consumer_thid[i], NULL);
	}
	
	sem_destroy(&g_sem);
	return 0;
}

运行结果如下,使生产者线程、消费者线程同步访问资源:
在这里插入图片描述


在这里插入图片描述

🎄四、计数信号量的使用例子

计数信号量是指初始化时信号值大于1的信号量,它可以与多个相同的资源关联,允许多个线程并发的使用多个资源。在某种程度上来说,计数信号量是对互斥量的一个扩展,互斥量是同一时间内只允许一个线程访问共享资源,而计数信号量允许多个线程并发访问共享资源。

可以用下面这个例子来加深理解:
1、互斥量相当于只有一个洗手间和一把钥匙,要想进入这个洗手间就要先拿到钥匙,进入洗手间,使用完又把钥匙放回去。
2、计数信号量相当于公共卫生间里的4个厕所和4把钥匙,要想进入厕所就先看看还有几把钥匙,如果没钥匙了就等待,有钥匙放出来就拿钥匙开锁进入洗手间。

下面以上厕所为例,举个计数信号量的例子,8个线程准备使用4个厕所资源,每个线程上两次厕所:

// 10_sem_multiple.c
// gcc 10_sem_multiple.c -lpthread
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>

#define  TOILET_NUM		4
#define  PEOPLE_NUM 	8

int 			toilets[TOILET_NUM] = {0,};		// 4个蹲厕
pthread_mutex_t toilet_mutex = PTHREAD_MUTEX_INITIALIZER;	// toilets 的互斥量
sem_t 			g_sem;

int getToilet()
{
	int i=0;
	for(i=0; i<TOILET_NUM; i++)
	{
		if(toilets[i] == 0)
			break;
	}
	return i;
}

int sem_value()
{
	int semvalue = 0;
	sem_getvalue(&g_sem, &semvalue);
	return semvalue;
}

// 上厕所线程
void *going_to_the_toilet(void *arg)
{
	int id = *((int*)arg);
	int count = 2;
	while(count-->0){
		printf("线程[%d] 等待厕所,厕所数量=%d\n",id, sem_value());
		sem_wait(&g_sem);
		pthread_mutex_lock(&toilet_mutex);	// 厕所有多个线程访问,加锁
		int i = getToilet();
		if(getToilet()==TOILET_NUM){
			printf("线程[%d], No toilet\n",id);
		}
		else{
			toilets[i] = 1;		// 表示进入该厕所
			printf("线程[%d] 进入厕所[%d], 即将工作 2s\n",id, i);
			pthread_mutex_unlock(&toilet_mutex); // 上厕所前先释放锁,让其他人可以访问厕所资源
			sleep(2);		// 正在上厕所...
			pthread_mutex_lock(&toilet_mutex);
			toilets[i] = 0;
			printf("线程[%d] 完成工作,厕所[%d]空闲\n",id, i);
		}
		pthread_mutex_unlock(&toilet_mutex);
		sem_post(&g_sem);
		sleep(1);	// 释放资源后,休眠1秒,确保资源让出去
	}
	return NULL;
}

int main()
{
	sem_init(&g_sem, 0, TOILET_NUM);// 初始化信号量值为4
	
	// 创建线程
	pthread_t people_thid[PEOPLE_NUM];
	int i=0, num[PEOPLE_NUM]={0,};
	for(i=0; i<PEOPLE_NUM; i++)
	{
		num[i] = i;
		pthread_create(&people_thid[i], NULL, going_to_the_toilet, &num[i]);
	}
	
	// 等待线程
	for(i=0; i<PEOPLE_NUM; i++)
	{
		pthread_join(people_thid[i], NULL);
	}
	
	sem_destroy(&g_sem);
	return 0;
}

运行结果如下:
在这里插入图片描述


在这里插入图片描述

🎄五、总结

👉本文介绍了信号量的一些基础知识,然后描述了在多线程编程下使用无名信号量的几个场景,并给出了使用例子。

在这里插入图片描述
如果文章有帮助的话,点赞👍、收藏⭐,支持一波,谢谢 😁😁😁

  • 32
    点赞
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 28
    评论
在嵌入式Linux平台下,多线程之间的同步和互斥可以使用信号量实现信号量是一种多线程间通信的机制,用于控制多个线程对共享资源的访问。 使用信号量需要引入头文件#include <semaphore.h>。 信号量的基本操作有三个函数: 1. sem_init():初始化信号量,设置信号量的初值。 2. sem_wait():等待信号量,如果信号量值为0,则线程阻塞等待,否则信号量值减1,线程继续执行。 3. sem_post():释放信号量,将信号量值加1。 下面是一个使用信号量实现线程同步例子: ```c #include <pthread.h> #include <semaphore.h> #include <stdio.h> sem_t sem; //定义信号量 int count = 0; //共享资源 void *thread_func(void *arg) { sem_wait(&sem); //等待信号量 count++; //对共享资源进行操作 printf("Thread %d: count = %d\n", *(int *)arg, count); sem_post(&sem); //释放信号量 pthread_exit(NULL); } int main() { pthread_t thread[5]; int i, id[5]; sem_init(&sem, 0, 1); //初始化信号量 for (i = 0; i < 5; i++) { id[i] = i; pthread_create(&thread[i], NULL, thread_func, &id[i]); } for (i = 0; i < 5; i++) { pthread_join(thread[i], NULL); } sem_destroy(&sem); //销毁信号量 return 0; } ``` 上面的例子中,共有5个线程同时对count变量进行操作,但是通过信号量使用,保证了每次只有一个线程能够访问共享资源。信号量sem的初值为1,表示有一个线程能够访问共享资源,其他线程需要等待。每个线程在访问共享资源之前都需要等待信号量sem,如果sem为0,则线程阻塞等待,否则sem减1,线程访问共享资源。当一个线程访问完共享资源之后,需要释放信号量sem,将sem加1,其他线程就可以访问共享资源了。最后,销毁信号量sem。 需要注意的是,在使用信号量时,要保证信号量使用线程安全的,否则会导致竞争条件的发生。在多线程环境下,使用信号量还需要考虑死锁的问题,避免出现死锁现象。
评论 28
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wkd_007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值