linux_信号量函数系列-信号量实现生产者消费者模型-sem_init函数-sem_wait函数-sem_post函数-sem_trywait函数

接上一篇：linux_条件变量_pthread_cond_wait函数_pthread_cond_timedwait函数_pthread_cond_signal函数_生产者消费者模型

  今天来分析信号量的学习，信号量相当于进化版的互斥锁（1 --> N），由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。
  这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。
  信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。
现在来看看信号量的主要内容吧：

此博主在CSDN发布的文章目录：我的CSDN目录，作为博主在CSDN上发布的文章类型导读

1.信号量-主要应用函数：

  信号量系列函数的返回值都是：成功返回0， 失败返回-1，同时设置errno。(注意，它们是没有pthread前缀)
  sem_t类型，本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节（类似于使用文件描述符）。
  sem_t sem; 规定信号量sem不能 < 0。头文件 <semaphore.h>

1.1.信号量基本操作：

sem_wait:   1、信号量大于0，则信号量-- （类比pthread_mutex_lock）
   |     2、信号量等于0，造成线程阻塞
  对应
   |
  sem_post： 将信号量++，同时唤醒阻塞在信号量上的线程 （类比pthread_mutex_unlock）
  但，由于sem_t的实现对用户隐藏，所以所谓的++、–操作只能通过函数来实现，而不能直接++、–符号。
  信号量的初值，决定了占用信号量的线程的个数。

1.2.sem_init函数

函数作用：
  初始化一个信号量。
头文件：
  #include <semaphore.h>
函数原型：
  int sem_init(sem_t *sem, int pshared, unsigned int value);
函数参数：
  sem：信号量
  pshared：取0用于线程间；取非0（一般为1）用于进程间
  value：指定信号量初值
返回值：
  成功：返回0；
  失败：返回-1，设置errno以指示错误。

1.3.sem_destroy函数

函数作用：
  销毁一个信号量。
头文件：
  #include <semaphore.h>
函数原型：
  int sem_destroy(sem_t *sem);
函数参数：
  sem：信号量
返回值：
  成功：返回0；
  失败：返回-1，设置errno以指示错误。

1.4.sem_wait函数

函数作用：
  给信号量加锁。 –
头文件：
  #include <semaphore.h>
函数原型：
  int sem_wait(sem_t *sem);
函数参数：
  sem：信号量
返回值：
  成功：返回0；
  失败：返回-1，设置errno以指示错误。

1.5.sem_post函数

函数作用：
  给信号量解锁。 ++
头文件：
  #include <semaphore.h>
函数原型：
  int sem_post(sem_t *sem);
函数参数：
  sem：信号量
返回值：
  成功：返回0；
  失败：返回-1，设置errno以指示错误。

1.6.sem_trywait函数

函数作用：
  尝试对信号量加锁。 - - (与sem_wait的区别类比lock和trylock)
头文件：
  #include <semaphore.h>
函数原型：
  int sem_trywait(sem_t *sem);
函数参数：
  sem：信号量
返回值：
  成功：返回0；
  失败：返回-1，设置errno以指示错误。

1.7.sem_timedwait函数

函数作用：
  限时尝试对信号量加锁。 - -
头文件：
  #include <semaphore.h>
函数原型：
  int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
函数参数：
  sem：信号量
  abs_timeout：采用的是绝对时间。
返回值：
  成功：返回0；
  失败：返回-1，设置errno以指示错误。
注意：
例如，定时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); 传参

2.生产者消费者信号量模型

使用信号量完成线程间同步，模拟生产者，消费者问题。
先分析：
规定： ①如果队列中有数据，生产者不能生产，只能阻塞。
    ②如果队列中没有数据，消费者不能消费，只能等待数据。
  定义两个信号量：S满 = 0， S空 = 1 （S满代表满格的信号量，S空表示空格的信号量，程序起始，格子一定为空）
所以有： T生产者主函数 {         T消费者主函数 {
       sem_wait(S空);         sem_wait(S满);
       生产…             消费…
       sem_post(S满);         sem_post(S空);
        }               }
  假设： 线程到达的顺序是:T生、T生、T消。
  那么： T生1 到达，将S空-1，生产，将S满+1
      T生2 到达，S空已经为0， 阻塞
      T消 到达，将S满-1，消费，将S空+1
  三个线程到达的顺序是：T生1、T生2、T消。而执行的顺序是T生1、T消、T生2
  这里，S空表示空格子的总数，代表可占用信号量的线程总数–>1。其实这样的话，信号量就等同于互斥锁。
  但，如果S空=2、3、4……就不一样了，该信号量同时可以由多个线程占用，不再是互斥的形式。因此我们说信号量是互斥锁的加强版。

代码如下：

//信号量实现 生产者 消费者问题

#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#define NUM 5               
int queue[NUM];                                     //全局数组实现环形队列
sem_t blank_number, product_number;                 //空格子信号量, 产品信号量
//生产者
void *producer(void *arg)
{
    int i = 0;
    while (1) 
    {
        sem_wait(&blank_number);                    //生产者将空格子数--,为0则阻塞等待
        queue[i] = rand() % 1000 + 1;               //生产一个产品
        printf("----Produce---%d\n", queue[i]);        
        sem_post(&product_number);                  //将产品数++
        i = (i+1) % NUM;                            //借助下标实现环形
        sleep(rand()%3);
    }
}
//消费者
void *consumer(void *arg)
{
    int i = 0;
    while (1) {
        sem_wait(&product_number);                  //消费者将产品数--,为0则阻塞等待
        printf("-Consume---%d\n", queue[i]);
        queue[i] = 0;                               //消费一个产品 
        sem_post(&blank_number);                    //消费掉以后,将空格子数++
        i = (i+1) % NUM;
        sleep(rand()%3);
    }
}
int main(int argc, char *argv[])
{
    pthread_t pid, cid;
    sem_init(&blank_number, 0, NUM);                //初始化空格子信号量为5
	sem_init(&product_number, 0, 0);                //产品数为0
	//创建生产者和消费者线程
    pthread_create(&pid, NULL, producer, NULL);
    pthread_create(&cid, NULL, consumer, NULL);
	//等待线程结束
    pthread_join(pid, NULL);
    pthread_join(cid, NULL);
	//销毁信号量
    sem_destroy(&blank_number);
    sem_destroy(&product_number);

    return 0;
}

  以上就是本次的分享了，希望对大家有所帮助，欢迎关注博主一起学习更多的新知识！