信号量

进化版的互斥锁（1 --> N）

     由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。

       信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。

主要应用函数：

       sem_init函数

       sem_destroy函数

       sem_wait函数

       sem_trywait函数 

       sem_timedwait函数   

       sem_post函数

以上6 个函数的返回值都是：成功返回0， 失败返回-1，同时设置errno。(注意，它们没有pthread前缀)

       sem_t类型，本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节（类似于使用文件描述符）。

sem_t sem; 规定信号量sem不能 < 0。头文件 <semaphore.h>

信号量基本操作：

sem_wait:      1. 信号量大于0，则信号量--          （类比pthread_mutex_lock）

         |                 2. 信号量等于0，造成线程阻塞

       对应

         |

       sem_post：   将信号量++，同时唤醒阻塞在信号量上的线程     （类比pthread_mutex_unlock）

但，由于sem_t的实现对用户隐藏，所以所谓的++、--操作只能通过函数来实现，而不能直接++、--符号。

信号量的初值，决定了占用信号量的线程的个数。

sem_init函数

初始化一个信号量

       int sem_init(sem_t *sem, int pshared, unsigned int value);

       参1：sem信号量

参2：pshared取0用于线程间；取非0（一般为1）用于进程间     

参3：value指定信号量初值

sem_destroy函数

销毁一个信号量

       int sem_destroy(sem_t *sem);

sem_wait函数

给信号量加锁 --

       int sem_wait(sem_t *sem);

sem_post函数

给信号量解锁 ++

        int sem_post(sem_t *sem);

sem_trywait函数

尝试对信号量加锁 --  (与sem_wait的区别类比lock和trylock)

        int sem_trywait(sem_t *sem);   

sem_timedwait函数

限时尝试对信号量加锁 --

       int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

       参2：abs_timeout采用的是绝对时间。               

       定时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); 传参

生产者消费者信号量模型

【练习】：使用信号量完成线程间同步，模拟生产者，消费者问题。                             【sem_product_consumer.c】

分析：

       规定：   如果□中有数据，生产者不能生产，只能阻塞。

                     如果□中没有数据，消费者不能消费，只能等待数据。

       定义两个信号量：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……就不一样了，该信号量同时可以由多个线程占用，不再是互斥的形式。因此我们说信号量是互斥锁的加强版。

【推演练习】：     理解上述模型，推演，如果是两个消费者，一个生产者，是怎么样的情况。             

【作业】：结合生产者消费者信号量模型，揣摩sem_timedwait函数作用。编程实现，一个线程读用户输入， 另一个线程打印“hello world”。如果用户无输入，则每隔5秒向屏幕打印一个“hello world”；如果用户有输入，立刻打印“hello world”到屏幕。

/***
sem_pro_con.c
***/
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#include<stdlib.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);
        queue[i] = rand() % 1000 + 1;
        printf("---Producer----%d
",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);
        printf("---Consumer---%d
",queue[i]);
        queue[i] = 0;
        sem_post(&blank_number);

        i = (i+1) % NUM;
        sleep(rand() % 3);
    }
}

int main()
{
    pthread_t pid,cid;
    sem_init(&blank_number,0,NUM);
    sem_init(&product_number,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;
    
}

运行结果：

ubuntu1604@ubuntu:~/wangqinghe/linux/20190821$ ./sem_pro

---Producer----384

---Consumer---384

---Producer----916

---Consumer---916

---Producer----387

---Consumer---387

---Producer----422

---Consumer---422

---Producer----691

---Consumer---691

---Producer----927

---Producer----427

^C