信号量

最新推荐文章于 2024-05-11 16:41:44 发布

取取经

最新推荐文章于 2024-05-11 16:41:44 发布

阅读量927

点赞数

分类专栏： linux 文章标签： linux 嵌入式

本文链接：https://blog.csdn.net/yahstudio/article/details/49640503

版权

linux 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

参考资料：百度百科，《嵌入式Linux应用程序开发详解》孙琼著/第9章/9.2 Linux线程实现/9.2.2 线程访问控制/2. 信号量线程控制

信号量是什么？

（参考百度百科）

信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种机制，是可以用来保证两个或多个关键代码段不被并发调用，（me：也可以用来保证某内存块不被并发使用）。

以一个停车场的运作为例。简单起见，假设停车场现在只剩下三个车位了（其他的都已经停着车了），这时如果同时来了十辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入外面的一辆进去，如果又离开五辆，则又可以放入五辆，如此往复。在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。

抽象的来讲，信号量的特性如下：信号量是一个非负整数（车位数），所有通过它的线程 /进程（车辆）都会将该整数减一（通过它当然是为了使用资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait（等待）和 Release（释放）。当一个线程调用Wait操作时，它要么得到资源然后将信号量减一，要么一直等下去（指放入阻塞队列），直到信号量大于等于一时。Release（释放）实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为释放了由信号量守护的资源。

（参考《嵌入式Linux应用程序开发详解》孙琼著/第9章/9.2 Linux线程实现/9.2.2 线程访问控制/2. 信号量线程控制）

在第8 章中已经讲到，信号量也就是操作系统中所用到的PV 原语，它广泛用于进程或线程间的同步与互斥。信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。这里先来简单复习一下PV 原语的工作原理。

PV 原语是对整数计数器信号量sem 的操作。一次P 操作使sem 减一，而一次V 操作使 sem 加一。进程（或线程）根据信号量的值来判断是否对公共资源具有访问权限。当信号量 sem 的值大于等于零时，该进程（或线程）具有公共资源的访问权限；相反，当信号量 sem 的值小于零时，该进程（或线程）就将阻塞直到信号量sem 的值大于等于0 为止。

PV 原语主要用于进程或线程间的同步和互斥这两种典型情况。若用于互斥，几个进程（或线程）往往只设置一个信号量sem，它们的操作流程如图9.2 所示。（互斥：可以借鉴互斥锁-mutex来理解；同步：用到时再说吧）

当信号量用于同步操作时，往往会设置多个信号量，并安排不同的初始值来实现它们之间的顺序执行，它们的操作流程如图9.3 所示。

函数说明

#include <semaphore.h>

       int sem_init(sem_t *sem, int pshared, unsigned int value);
函数功能：
    用于创建一个信号量，并初始化它的值。
参数说明：
    sem：信号量
    pshared：决定信号量能否在几个进程间共享。由于目前Linux还没有实现进程间共享信号量，所以这个值只能够取0。
    value：信号量初始化值。
返回值：
    成功：0
    出错：-1
注意：sem_init 的参数 value 是sem信号量的初始化值，并不是说sem信号量的最大值是value。比如说如果设置 sem_init 的 value = 3，相当于车库还有3个车位。每执行1次sem_post 操作（有1辆车离开），sem 信号量值都会加1（车库多1个车位）；而每执行1次 sem_wait 操作（有1辆车驶入），sem信号量值都会减1（车库少1个车位）。

       int sem_wait(sem_t *sem);
       int sem_trywait(sem_t *sem);
       int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
函数功能：
    这三个 wait 函数都相当于P 操作，它们都能将信号量的值减一。不同点在于若信号量小于零时，sem_wait 将会阻塞进程，sem_trywait 会立即返回，而 sem_timedwait 则会阻塞一段时间（abs_timeout）后再返回。还是以停车场为例，sem_wait 是死板的一直等下去；sem_trywait 是如果没有车位就立即走人；sem_timedwait 是等待一段时间后，如果还没有车位则走人。后面有一个例子是专门讲sem_timedwait 函数的。

       int sem_post(sem_t *sem);
函数功能：
    sem_post 相当于V 操作，它将信号量的值加一同时发出信号唤醒等待的进程。

       int sem_destroy(sem_t *sem);
函数功能：
    sem_destroy 用于删除信号量。

       int sem_getvalue(sem_t *sem, int *sval);
函数功能：
    sem_getvalue 用于得到信号量的值。

代码示例

    注意：这里使用的是互斥操作，也就是只使用一个信号量来实现。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <sys/ipc.h>
#include <semaphore.h>

int lock_var;
time_t end_time;
sem_t sem;
void pthread1(void *arg);
void pthread2(void *arg);
void pthread3(void *arg);

int main(int argc, char *argv[])
{
        pthread_t id1, id2, id3;
        pthread_t mon_th_id;
        int ret;
        end_time = time(NULL) + 30;

        /*初始化信号量为1*/
        ret = sem_init(&sem, 0, 2);
        if(ret!=0)
        {
                perror("sem_init");
        }

        /*创建两个线程*/
        ret = pthread_create(&id1, NULL, (void *)pthread1, NULL);
        if(ret != 0)
                perror("pthread cread1");
        ret = pthread_create(&id2, NULL, (void *)pthread2, NULL);
        if(ret != 0)
                perror("pthread cread2");
        ret = pthread_create(&id3, NULL, (void *)pthread3, NULL);
        if(ret != 0)
                perror("pthread cread3");

        pthread_join(id1, NULL);
        pthread_join(id2, NULL);
        pthread_join(id3, NULL);

        ret = sem_destroy(&sem);
        if(ret != 0)
                perror("sem_destroy");

        exit(0);
}

void pthread1(void *arg)
{
        int i;
        while(time(NULL) < end_time)
        {
                int semvalue = -1;
                sem_getvalue(&sem, &semvalue);
                printf("pthread1: before sem_wait, semvalue = %d\n", semvalue);

                /*信号量减一，P操作*/
                sem_wait(&sem);
                sem_getvalue(&sem, &semvalue);
                printf("pthread1: get lock, semvalue = %d\n", semvalue);
                for(i=0;i<2;i++)
                {
                        sleep(1);
                        lock_var++;
                        printf("pthread1: lock_var = %d\n",lock_var);
                }

                /*信号量加一，V操作*/
                sem_post(&sem);
                sem_getvalue(&sem, &semvalue);
                printf("pthread1: release lock, semvalue = %d\n", semvalue);

                sleep(3);
        }
}

void pthread2(void *arg)
{
        int nolock=0;
        int ret;
        while(time(NULL) < end_time)
        {
                int semvalue = -1;
                sem_getvalue(&sem, &semvalue);
                printf("pthread2: before sem_wait, semvalue = %d\n", semvalue);

                /*信号量减一，P操作*/
                sem_wait(&sem);
                sem_getvalue(&sem, &semvalue);
                printf("pthread2: get lock, semvalue = %d\n", semvalue);
                printf("pthread2: lock_var = %d\n",lock_var);

                /*信号量加一，V操作*/
                sem_post(&sem);

                sem_getvalue(&sem, &semvalue);
                printf("pthread2: release lock, semvalue = %d\n", semvalue);

                sleep(3);
        }
}

void pthread3(void *arg)
{
        int nolock=0;
        int ret;
        while(time(NULL) < end_time)
        {
                int semvalue = -1;
                sem_getvalue(&sem, &semvalue);
                printf("pthread3: before sem_wait, semvalue = %d\n", semvalue);

                /*信号量减一，P操作*/
                sem_wait(&sem);
                sem_getvalue(&sem, &semvalue);
                printf("pthread3: get lock, semvalue = %d\n", semvalue);
                printf("pthread3: lock_var = %d\n",lock_var);

                /*信号量加一，V操作*/
                sem_post(&sem);

                sem_getvalue(&sem, &semvalue);
                printf("pthread3: release lock, semvalue = %d\n", semvalue);

                sleep(3);
        }
}

编译/执行
xj@ubuntu-server:~/semaphore$ gcc main.c -lpthread
xj@ubuntu-server:~/semaphore$ ./a.out
pthread1: before sem_wait, semvalue = 2
pthread1: get lock, semvalue = 1
pthread3: before sem_wait, semvalue = 1
pthread2: before sem_wait, semvalue = 2
pthread2: get lock, semvalue = 0
pthread2: lock_var = 0
pthread2: release lock, semvalue = 1
pthread3: get lock, semvalue = 0
pthread3: lock_var = 0
pthread3: release lock, semvalue = 1
pthread1: lock_var = 1
pthread1: lock_var = 2
pthread1: release lock, semvalue = 2
pthread3: before sem_wait, semvalue = 2
pthread3: get lock, semvalue = 1
pthread3: lock_var = 2
pthread3: release lock, semvalue = 2
pthread2: before sem_wait, semvalue = 2
pthread2: get lock, semvalue = 1
pthread2: lock_var = 2
pthread2: release lock, semvalue = 2
pthread1: before sem_wait, semvalue = 2
pthread1: get lock, semvalue = 1
pthread3: before sem_wait, semvalue = 1
pthread2: before sem_wait, semvalue = 1
pthread1: lock_var = 3
pthread3: get lock, semvalue = 0
pthread3: lock_var = 3
pthread2: get lock, semvalue = 0
pthread2: lock_var = 3
pthread2: release lock, semvalue = 1
pthread3: release lock, semvalue = 1
pthread1: lock_var = 4
pthread1: release lock, semvalue = 2
pthread2: before sem_wait, semvalue = 2
pthread2: get lock, semvalue = 1
pthread2: lock_var = 4
pthread2: release lock, semvalue = 2
pthread3: before sem_wait, semvalue = 2
pthread3: get lock, semvalue = 1
pthread3: lock_var = 4
pthread3: release lock, semvalue = 2
…… …… ……
中间很多是类似的，这里略去。
…… …… ……
pthread1: before sem_wait, semvalue = 2
pthread1: get lock, semvalue = 1
pthread1: lock_var = 11
pthread3: before sem_wait, semvalue = 1
pthread3: get lock, semvalue = 0
pthread3: lock_var = 11
pthread3: release lock, semvalue = 1
pthread2: before sem_wait, semvalue = 1
pthread2: get lock, semvalue = 0
pthread2: lock_var = 11
pthread2: release lock, semvalue = 1
pthread1: lock_var = 12
pthread1: release lock, semvalue = 2
xj@ubuntu-server:~/semaphore$