一，信号量的概念

信号量（semaphore）本质上是一个计数器，用于多进程对共享数据对象的读取，它和管道有所不同，它不以传送数据为主要目的，它主要是用来保护共享资源（信号量也属于临界资源），使得资源在一个时刻只有一个进程独享。 在信号量进行PV操作时都为原子操作（因为它需要保护临界资源）。

嵌入式进阶教程分门别类整理好了，看的时候十分方便，由于内容较多，这里就截取一部分图吧。

需要的朋友私信【内核】即可领取。

二，信号量的结构

信号量的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。 信号量的值与相应资源的使用情况有关: 当信号量的值大于0时，表示当前可用资源的数量 ；当它的值小于0时，其绝对值表示等待使用该资源的进程个数 。

三，信号量对应的操作

信号量的值仅能由PV操作来改变。

什么是PV操作：

P操作：

sem变量减1 （获得资源）

若sem>=0，则P操作返回，该线程程可以“通过”并继续执行。

若sem<0，则该线程被阻塞，进入操作系统的阻塞队列。

V操作：

sem变量加1（释放资源）

若sem>0，则V操作返回，该线程继续执行。

若sem<=0，则从阻塞队列中唤醒一个阻塞在该信号量上的线程，然后再返回原线程（调用ν操作的线程）继续执行。

Linux多进程访问共享资源时，需要按下列步骤进行操作：

(1)检测控制这个资源的信号量的值。

(2)如果信号量是正数，就可以使用这个资源。进程将信号量的值“减 1”，表示当前进程占用了一份资源。访问资源结束后再执行“加 1”操作。

(3)如果信号量是0，那么进程进入睡眠状态，直到信号量的值重新大于0时被唤醒，转入第一步操作。

四，信号量的分类

信号量按照使用场景分为 ：二值信号量和计数信号量：

二值信号量：指初始值为 1 的信号量，此类信号量只有 1 和 0 两个值，通常用来代替锁机制实现线程同步， 在一个时刻仅允许有一个资源持有者；

计数信号量：指初始值大于 1 的信号量，当进程中存在多个线程，但某公共资源允许同时访问的线程数量是有限的，它允许在一个时刻至多有count个资源持有者，这时就可以用计数信号量来限制同时访问资源的线程数量。

*临界资源在同一时刻只允许一个进程使用，此时的信号量是一个二值信号量，它只控制一个资源；另一种应用于处理多个共享资源（例如多台打印机的分配），信号量在其中起到记录空闲资源数目的作用，此时的信号量是计数信号量。

五，信号量的处理函数

对应的头文件： #include <semaphore.h>

1.得到或者创建一个信号量：

semget函数
int semget(key_t key, int nsems, int semflg);
--功能：用来创建和访问一个信号量集
--参数:
key：信号集的key值
nsems：信号集中信号量的个数
semflg：由九个权限标志构成，他们的用法和创建文件时使用的mode模式标志是一样的
--返回值：
成功返回一个非负整数，即该信号集的标识码，失败返回-，并且更新errno

2.初始化信号量：

int sem_init(sem_t *sem, int pshared, unsigned int value);
参数说明:
a. sem为指向未初始化信号量结构的一个指针
b. pshared参数表示这个信号量是在进程的线程之间共享，还是在进程之间共享。
    如果pshared的值为0，那么这个信号量会在进程的线程之间共享，并且应该位于对所有线程都可见的某个地址
    如果pshared非零，那么这个信号量将在进程之间共享，并且应该位于共享内存的某个区域，(因为fork创建的子进程会继承父进程的内存映射，所以它也可以获取信号量)。
    任何可以访问共享内存区域的进程都可以使用sem_post、sem_wait等对这个信号量进行操作。
c. value指定信号量的初始值
功能:
初始化信号量
返回值:成功返回0，失败返回-1

3.销毁信号量：

int sem_destroy(sem_t *sem);
参数说明:
sem为通过sem_init(3)初始化的信号量
功能:
释放信号量
返回值:成功返回0，失败返回-1

4.给信号量“加1”

int sem_post(sem_t *sem);
参数说明:
sem为通过sem_init初始化的信号量
功能:
sem_post函数的作用是给信号量的值加上一个“1”，它是一个“原子操作”－－－即同时对同一个信号量做加“1”操作的两个线程是不会冲突的；
信号量的值永远会正确地加一个“2”－－因为有两个线程试图改变它。
返回值:成功返回0，失败返回-1

5.给信号量“减1”

int sem_wait(sem_t *sem);
参数说明:
sem为通过sem_init初始化的信号量
功能:
sem_wait函数也是一个原子操作，它的作用是从信号量的值减去一个“1”，但它永远会先等待该信号量为一个非零值才开始做减法。
也就是说，如果你对一个值为2的信号量调用sem_wait(),线程将会继续执行,信号量的值将减到1。如果对一个值为0的信号量调用sem_wait()，
这个函数就会地等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值，
那么当它被第三个线程增加 一个“1”时，等待线程中只有一个能够对信号量做减法并继续执行，另一个还将处于等待状态。
返回值:成功返回0，失败返回-1

注意：给资源加锁的时候等价于信号量“减1”，释放锁的时候等价于信号量“加1”，所以是先执行sem_wait, 后执行sem_post。

六，具体的编程练习

信号量编程步骤：

• 1.定义信号量:sem_t
• 2.初始化信号量:sem_init(sem_t *);
• 3.加锁：sem_wait()
• 4.执行业务逻辑代码
• 5.解锁：sem_post
• 6.销毁信号量：sem_destroy

Demo 1: 简单的信号量框架

#include <pthread.h>
#include <semaphore.h>

sem_t mutex;

void *my_thread(void *arg){
    while(1){
        sem_wait(&mutex);
        //some process code
        sem_post(&mutex);
    }
}

int main(){
    pthread_t thread_1, thread_2;

    sem_init(&mutex, 0 ,1);
    pthread_create(&thread_1, NULL, &my_thread, NULL);
    pthread_create(&thread_2, NULL, &my_thread, NULL);
    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);
    sem_destroy(&mutex);
}

Demo2: 用信号量解决消费者-生产者问题

#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>
#include <stdio.h>

#define MaxItems 5
#define BufferSize 5

sem_t empty;
sem_t full;
int in = 0;
int out = 0;
int buffer[BufferSize];
pthread_mutex_t mutex;

void *producer(void *pno)
{   
    int i;
    int item;
    for(i = 0; i < MaxItems; i++) {
        item = rand();
        sem_wait(&empty);
        pthread_mutex_lock(&mutex);
        buffer[in] = item;
        printf("Producer %d: Insert Item %d at %d\n", *((int *)pno),buffer[in],in);
        in = (in+1)%BufferSize;
        pthread_mutex_unlock(&mutex);
        sem_post(&full);
    }
}
void *consumer(void *cno)
{   
    int i;
    for(i = 0; i < MaxItems; i++) {
        sem_wait(&full);
        pthread_mutex_lock(&mutex);
        int item = buffer[out];
        printf("Consumer %d: Remove Item %d from %d\n",*((int *)cno),item, out);
        out = (out+1)%BufferSize;
        pthread_mutex_unlock(&mutex);
        sem_post(&empty);
    }
}

int main()
{   
    pthread_t pro[5],con[5];
    pthread_mutex_init(&mutex, NULL);
    sem_init(&empty,0,BufferSize);
    sem_init(&full,0,0);
    int i;
    int a[5] = {1,2,3,4,5};

    for(i = 0; i < 5; i++) {
        pthread_create(&pro[i], NULL, (void *)producer, (void *)&a[i]);
    }
    for(i = 0; i < 5; i++) {
        pthread_create(&con[i], NULL, (void *)consumer, (void *)&a[i]);
    }

    for(i = 0; i < 5; i++) {
        pthread_join(pro[i], NULL);
    }
    for(i = 0; i < 5; i++) {
        pthread_join(con[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    sem_destroy(&empty);
    sem_destroy(&full);
    return 0;
    
}

编译方式：

gcc sem_test.c -lpthread -o sem_test
./sem_test

Demo3：吸烟者问题

假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料:烟草、纸和胶水。三个抽烟者中，第一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者进程一个信号告诉完成了，供应者就会放另外两种材料再桌上，这个过程一直重复(让三个抽烟者轮流地抽烟)

根据题目我们知道，放在桌上的材料一共有三种组合方式

1. 纸和胶水（offer1）会被一号吸烟者取走
2. 烟草和胶水（offer2）会被二号吸烟者取走
3. 烟草和纸（offer3）会被三号吸烟者取走

本题可以看作是存在一个生产者和多个消费者的问题，同时生产者所生产的物品并不相同 C语言伪代码：

semaphore offer1=0; //桌上组合一的数量
semaphore offer2=0; //桌上组合二的数量
semaphore offer3=0; //桌上组合三的数量
semaphore finish=0; //抽烟是否完成
int i=0; //用于实现三个吸烟者轮流吸烟

//供应者进程
provider(){
    while(1){
        if(i==0){
            将组合一放桌上
            V(offer1); //提醒一号吸烟者吸烟
        }else if(i==1){
            将组合二放桌上
            V(offer2); //提醒二号吸烟者吸烟
        }else{
            将组合三放桌上
            V(offer3); //提醒三号吸烟者吸烟
        }
        i=(i+1)%3; //实现让三个吸烟者轮流吸烟
        P(finish); //等待吸烟者吸烟完成后继续放组合
    }
}

//一号吸烟者进程
smoker1(){
    while(1){
        P(offer1); //等待组合一放到桌上
        从桌上拿走组合一，吸烟
        V(finish); //提醒供应者提供新组合
    }
}

//二号吸烟者进程
smoker2(){
    while(1){
        P(offer2); //等待组合二放到桌上
        从桌上拿走组合二，吸烟
        V(finish); //提醒供应者提供新组合
    }
}

//三号吸烟者进程
smoker3(){
    while(1){
        P(offer3); //等待组合三放到桌上
        从桌上拿走组合三，吸烟
        V(finish); //提醒供应者提供新组合
    }
}

具体代码实现：

#include <stdio.h>
#include <sys/types.h>
#include <semaphore.h>

int table_used = 1;
int generated_item[2];
int generated = 0;

char *item[] = {"tubaco", "paper", "matches"};
sem_t table;

//供应者进程
void *agent(void *arg)
{
    int i,j,k=0;
    while(1)
    {
        sleep(1);
        sem_wait(&table);
        if (table_used == 1)
        {
            i = k;
            j = i + 1;
            if (j == 3)
                j = 0;
            k = j;
            
            //模拟三种不同的组合
            //[0,1] --> 吸烟者2抽烟
            //[1,2] --> 吸烟者0抽烟
            //[2,0] --> 吸烟者1抽烟
            generated_item[0] = i;
            generated_item[1] = j;

            printf("agent is produced %s,%s\n", item[i], item[j]);
            generated = 1;
            table_used = 0;
        }
        sem_post(&table);
    }
}

void *smoker(int i)
{
    while(1)
    {
        sleep(1);
        sem_wait(&table);
        if (table_used == 0)
        {
            if(generated && generated_item[0] != i && generated_item[1] != i)
            {
                printf("smoker%d completed his smoking\n", i);
                //释放桌子的空间
                table_used = 1;
                generated = 0;
            }
        }
        sem_post(&table);
    }
}

main()
{
    pthread_t smk_0, smk_1, smk_2, agent;
    sem_init(&table,0,1);
    pthread_create(&agent, 0, agent, 0);
    pthread_create(&smk_0, 0, smoker, 0);
    pthread_create(&smk_1, 0, smoker, 1);
    pthread_create(&smk_2, 0, smoker, 2);
    while(1);
}

Linux部分第一篇，未完待续....

原文地址：https://cloud.tencent.com/developer/article/1998048（版权归原作者所有，侵删）