信号量实现linux线程的同步与互斥

linux线程编程：https://blog.csdn.net/David_361/article/details/86639865

本片博客接着前面的线程编程继续介绍在linux中用信号量实现线程间的同步与互斥

信号量

信号量就是操作系统中所用到的PV原子操作，它被广泛用到进程于线程间的同步与互斥。信号量本质上是一个非负的整数计数器，它被用来对公共资源的访问。PV原子操作主要用于进程或线程间的同步与互斥这两种典型情况。若用于互斥，几个进程（或线程）往往只设置一个信号量sem。当用于同步操作的时候，往往会设置多个信号量，并安排不同的初始值来实现它们之间的顺序执行。

（1）信号量常用函数介绍

sem_init()用于初始化信号量

所需头文件	#include <semaphore.h>
函数原型	int sem_init(sem_t *sem, int pshared, unsigned int value);
函数传入值	sem：信号量对象
	pshared：决定信号量能否在进程间共享。由于目前linux还没有实现进程间共享信号量，所以这个值只能够取0，就表示信号量用于进程内部的线程间
	value：信号量初始化的值
函数返回值	成功：0
函数返回值	出错：-1

sem_wait()和sem_trywait()都相当于P操作，在信号量大于0时，他们都能见信号量的值减1。两者的区别在于若信号量的值为0时，sem_wait()将会阻塞线程，而sem_trywait()则会立即返回。下面列出一些函数的语法要点

所需头文件	#include <semaphore.h>
函数原型	int sem_wait(sem_t sem); //获取信号量，若不成功则阻塞 int sem_trywait(sem_t sem); //获取信号量，若不成功则立即返回 int sem_post(sem_t sem); //释放信号量 int sem_getvalue(sem_t sem, int sval); //获取信号量的值，是把 sem 指向的信号量当前值放置在 sval 指向的整数上 int sem_destroy(sem_t sem); //产出信号量注：编译时需要加上-pthread
函数传入值	sem：信号量对象
函数返回值	成功：0
函数返回值	出错：-1

（2）实例代码演示

这里通过使用经典的“生产者消费者”问题，来演示信号量处理线程间的同步和互斥问题。

问题描述如下：

有一个有限缓冲区（这里用又名管道来实现FIFO式缓冲区）和两个线程：生产者和消费者，他们不停的把产品放入缓冲区和从缓冲区取走产品。一个生产者和缓冲区满的时候必须等待，一个消费者在缓冲区空的时候也必须等待。另外因为缓冲区是临界资源，所以生产者与消费者之间也必须互斥执行。实现方法是是使用有名管道来来模拟有限缓冲区，并且使用信号来解决“生产者和消费之”问题中的同步与互斥

/*producer_customer.c
* 这里使用三个信号量，其中两个信号量avail和full分别用于解决生产者与消费者之间的同步关系，
* mutex是用于解决两个线程之间的互斥问题
* avail表示缓冲区中的单元数，初始值为N
* full表示缓冲区中非空单元数，初始值为0
* mutex是互斥信号，初始值为1（也可以使用互斥锁来实现互斥操作）
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <semaphore.h>
#include <pthread.h>
#include <errno.h>
#include <sys/ipc.h>

#define MYFIFO "myfifo"
#define BUFFER_SIZE 3
#define UNIT_SIZE 5
#define RUN_TIME 30
#define DELAY_TIME_LEVELS 5.0

int fd;
time_t end_time;
sem_t mutex, full, avail;


void *producer(void *arg)
{
	int real_write;
	int delay_time = 0;
	while(time(NULL) < end_time)
	{
		delay_time = (int)(rand()*DELAY_TIME_LEVELS/(RAND_MAX) / 2.0) + 1;
		sleep(delay_time);
		sem_wait(&avail);
		sem_wait(&mutex);
		printf("\nProductor: delay = %d\n", delay_time);
		/*生产者写入数据*/
		if((real_write = write(fd, "hello", UNIT_SIZE)) == -1)
		{
			if(errno == EAGAIN)
			{
				printf("The FIFO has not been read yet.Please try later\n");
			}
		}
		else
		{
			printf("Write %d to the FIFO\n", real_write);
		}
		/*V操作信号量full和mutex*/
		sem_post(&full);
		sem_post(&mutex);
	}
	pthread_exit(NULL);
}

void *customer(void *arg)
{
	unsigned char read_buffer[UNIT_SIZE];
	int real_read;
	int delay_time;
	
	while(time(NULL) < end_time)
	{
		delay_time = (int)(rand() *DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
		sleep(delay_time);
		/*P操作信号量full和mutex*/
		sem_wait(&full);
		sem_wait(&mutex);
		memset(read_buffer, 0, UNIT_SIZE);
		printf("\nCustomer: delay =  %d\n", delay_time);
		if((real_read = read(fd, read_buffer, UNIT_SIZE)) == -1)
		{
			if(errno == EAGAIN)
			{
				printf("NO data yet\n");
			}
		}
		printf("Read %s from FIFO\n", read_buffer);
		/*V操作信号量avail和mutex*/
		sem_post(&avail);
		sem_post(&mutex);
	}
	pthread_exit(NULL);
}


int main(int argc, char *argv[])
{
	
	pthread_t thrd_prd_id, thrd_cst_id;
	pthread_t mon_th_id;
	int ret;
	
	end_time = time(NULL) + RUN_TIME;
	/*创建有名管道*/
	if((mkfifo(MYFIFO, O_CREAT|O_EXCL) < 0) && (errno != EEXIST))
	{
		printf("Cannot creat fifo");
		return errno;
	}
	/*打开管道*/
	if((fd = open(MYFIFO, O_RDWR)) == -1)
	{
		printf("Open fifo error");
		return fd;
	}
	/*初始化互斥信号量为1*/
	ret = sem_init(&mutex, 0, 1);
	ret += sem_init(&avail, 0, BUFFER_SIZE);
	ret += sem_init(&full, 0, 0);
	
	if(ret != 0)
	{
		printf("Any semaphore initialization faild\n");
		return ret;
	}
	
	/*创建两个线程*/
	ret = pthread_create(&thrd_prd_id, NULL, producer, NULL);
	if(ret != 0)
	{
		printf("Creat producer thread error\n");
		return ret;
	}
	
	ret = pthread_create(&thrd_cst_id, NULL, customer, NULL);
	if(ret != 0)
	{
		printf("Creat customer thread error\n");
		return ret;
	}
	
	pthread_join(thrd_prd_id, NULL);
	pthread_join(thrd_cst_id, NULL);
	close(fd);
	unlink("MYFIFO");
	return 0;
}

运行结果

信号量实现linux线程的同步与互斥

猜你喜欢