【Linux多线程编程】7. 线程锁（4）——信号量

前言

上篇文章Linux多线程编程】6. 线程锁（3）——条件变量 介绍了使用条件变量实现多线程同步的方式，而条件变量一般与互斥锁一同配合。本文介绍多线程同步的另一种方式——信号量，使用比条件变量简单，也用来解决生产者-消费者问题。

信号量

一个信号量 S 是个整型变量，它除了初始化外只能通过两个标准原子操作：wait () 和 signal() 来访问：

操作 wait() 也称为 P
操作 signal() 也称为 V

对于wait() 和 signal() 的定义可以如下

wait(S){
    while (S <= 0)
        ;// busy wait
    S--；// 信号量S减
}
signal(S) {
    S++; // 信号量S加
}

由上代码不难看出，信号量看起来就是一个计数变量，wait对计数变量-1，signal对计数变量+1。
与普通定义一个变量，然后++/–的区别在于，信号量的操作是原子性的。

原子性：指事务的不可分割性，一个事务的所有操作要么不间断地全部被执行，要么一个也没有执行。

可以简单的将其理解为线程安全的，而对普通变量的加减之前我们说过是线程不安全的。

操作系统通常区分计数信号量与二进制信号量。计数信号量的值不受限制，而二进制信号量的值只能为 0 或 1。因此，二进制信号量类似于互斥锁。事实上，在没有提供互斥锁的系统上，可以使用二进制信号量来提供互斥。
实际上，互斥锁我们可以看为只支持0/1变化的信号量

使用场景

信号量用于线程安全性的计数，通常这种功能被用在共享资源的访问上。
比如：
一家餐馆招了4个厨师，原料柜上放着3瓶酱油，我们可以为生菜加上一个信号量。
厨师A在t1时刻拿走一个生菜，此时生菜信号量-1，剩余2捆生菜；
厨师B在t2时刻拿走一个生菜，此时生菜信号量-1，剩余1捆生菜；
厨师C在t3时刻拿走一个生菜，此时生菜信号量-1，剩余0捆生菜；
厨师D在t4时刻想要拿走一个生菜，而此时生菜信号量为0，因此厨师D拿不到生菜，阻塞等待其他厨师释放已用的生菜；

看这个流程是不是跟之前说的互斥锁很像？区别在于：

信号量适用于多个线程在有多个相同资源时，资源数不为0，线程就可拿取资源；为0则等待
互斥锁是多个线程只有一个相同资源，其他线程抢先获取，另外的线程都阻塞等待。

因此，我们理解互斥锁就是只支持0/1计数的信号量。

主要函数

头文件 #define <semaphore.h>

1. 创建信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);
参数：
sem：传出参数，函数返回后指向创建后的信号量。
pshared：控制信号量的类型，如果值为0，就表示这个信号量是当前进程的局部信号量，在当前进程的多个线程之间共享，否则信号量就可以在多个进程之间共享；
value：sem的初始值。
返回值：
调用成功时返回0，失败返回-1。

2. 信号量值-1

int sem_wait(sem_t *sem);
参数：
sem：sem_init调用初始化的信号量。
返回值：
调用成功返回0，失败返回-1。

3. 信号量的值+1

int sem_post(sem_t *sem);
参数：
sem：sem_init调用初始化的信号量。
返回值：
调用成功返回0，失败返回-1。

4. 释放信号量

int sem_destroy(sem_t *sem);
参数：
销毁用sem_init初始化的信号量。
返回值：
调用成功返回0，失败返回-1。

代码示例

以生产者消费者模型为例，用信号量实现这个功能

#include <semaphare.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t mutex;
sem_t psem;
sem_t csem;
struct Node{//创建链表
    int num;
    struct Node *next;
};
struct Node *head=NULL;//设置头结点为空
void *producer(void *arg)//生产者
{
    while(1)
    {
        sem_wait(&psem);//每进去一个车，公共车位就少一个，所以减一
        pthread_mutex_lock(&mutex);//上锁
        struct Node* newNode=(struct Node*)malloc(sizeof(struct Node));//开辟一块空间
        newNode->next=head;
        head=newNode;
        newNode->num=rand()%100;//取随机数
        printf("add node,num:%d,tid:%ld\n",newNode->num,pthread_self());
        pthread_mutex_unlock(&mutex);//解锁
        sem_post(&csem);//每次出去一个车，公共车位就多一个，所以加一
        usleep(100);
    }
        return NULL;

}
void *customer(void *arg)
{
    while(1)
    {
        sem_wait(&csem)//每次进去一个车，车位就减一
        pthread_mutex_lock(&mutex);//加锁
        struct Node *tmp=head;
        if(head!=NULL)
        {
            head=head->next;
            printf("del node,num:%d,tid:%ld\n",tmp->num,pthread_self());
            free(tmp);
            pthread_mutex_unlock(&mutex);//解锁
            sem_post(&psem);//每次出去一个车，车位就增加一个
        }
        return NULL;
    }
}
int main()
{
    pthread_mutex_init(&mutex,NULL);//初始化互斥锁
    sem_init(&psem,0,8);//初始化8个生产者空间
    sem_init(&csem,0,0);//初始化消费者，刚开始还没有消费，所以初始化为0
    
    pthread_t ptids[5],ctids[5];
    for(int i=0;i<5;i++)
    {
        pthread_create(&ptids[i],NULL,producer,NULL);//创建五个生产者线程
        pthread_create(&ctids[i],NULL,customer,NULL);//创建五个消费者线程
    }
    for(int i=0;i<5;i++)
    {
        pthread_join(ptids[i],NULL);//回收生产者子线程
        pthread_join(ctids[i],NULL);//回收消费者子线程
    }
    while(1)
    {
        sleep(10);
    }
    pthread_mutex_destroy(&mutex);//解除互斥锁
    sem_destroy(&psem);//释放生产者资源
    sem_destroy(&csem);//释放消费者资源
    pthread_exit(NULL);
    return 0;
}

通过观察我们会看到，有时候增加一个数字，就相应的减少一个数字，有时候同时增加几个数字，则按照栈操作顺序输出数字。

所以，运用信号量可以非常明显的实现了这个功能。