Linux应用编程—10.信号量

​ 信号量用于任务间的同步!简单来理解，信号量是一个被内核维护的整数，这个整数一般是“大于等于零”的，我们对这个信号量的操作一般为：将信号量设置一个值、发布(加上一个信号量)、消耗(减去一个信号量)、等待信号量的值为0。在POSIX下信号量分为命名信号量与未命名信号量。未命名信号量，也被称为基于内存的信号量，类型为sem_t，创建未命名信号量使用的函数为sem_init()。

10.1 初始化一个信号量

​ 初始化信号量函数sem_init()，在Linux终端下查看该函数。

NAME
       sem_init - initialize an unnamed semaphore

SYNOPSIS
       #include <semaphore.h>

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

       Link with -pthread.

​ 该函数用来初始化一个无名信号量，使用时包含头文件semaphore.h，编译时需要跟上后缀-pthread。函数传参有3个，sem_t *sem是sem_t类型的地址，可以理解为我们创建信号量的id，int pshared，这个参数决定了我们创建的信号量是在进程间共享还是单个进程中的线程间共享。unsigned int value是信号量的初始值，一般为一个大于等于0的整数。

10.2 销毁一个信号量

​ sem_destroy()函数用来销毁信号量，被销毁的信号量是之前使用sem_init()初始化的未命名信号量。

10.3 等待一个信号量

​ sem_wait()函数用来等待一个信号量，此时会对信号量-1，如果信号量的当前值大于0，则该函数立即返回。如果等于0，该函数会阻塞调用进程直到信号量的值大于0为止，信号量值大于0时该信号量值被-1并且函数返回。

10.4 发布一个信号量

​ 发布一个信号量时，使用函数sem_post()函数。该函数会将信号量+1。

10.5 创建一个映射mmap()函数

​ mmap()函数用来在调用进程的虚拟地址空间中创建一个新映射。

NAME
       mmap, munmap - map or unmap files or devices into memory

SYNOPSIS
       #include <sys/mman.h>

       void *mmap(void *addr, size_t length, int prot, int flags,
                  int fd, off_t offset);
       int munmap(void *addr, size_t length);

       See NOTES for information on feature test macro requirements.

​ 调用该函数需要包含头文件sys/mman.h，函数原型为：void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);其中addr参数指定该映射被放置的虚拟地址，将该参数赋值为NULL，那么内核会为映射选择一个合适的地址；length参数指定映射的字节数；port参数可以写入：PROT_NONE:区域无法访问、PROT_READ:区域内容可读取、PROT_WRITE:区域内容可修改、PROT_EXEC:区域内容可执行。这个映射地址会用来存放信号量id，所以要可读可写；flags参数是一个控制映射操作各个法面的选项的位掩码，可写入：MAP_PRIVATE:创建一个私有映射；MAP_SHARED：创建一个共享映射；fd与offset用于文件映射，fd参数是一个标识被映射的文件的文件描述符；offset参数指定了映射在文件中的起点。默认可以填入0。

10.6 信号量编程实践

​ 初始化一个信号量，它在父子进程之间被共享。共享方式可以使用创建共享内存或者使用mmap()函数。创建一对父子进程，父进程里面每隔1秒钟，等待一个信号量，然后打印字符串。子进程中每隔5秒钟打印字符串，并且发布一个信号量。由于该信号量初始化时，初始值为1，则父进程只执行一次后因为信号量=0而被sem_wait()阻塞。当子进程执行后，会发布信号量，此后父进程继续执行。

​ 代码如下。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <semaphore.h>
#include <sys/mman.h>

int main(void)
{
        pid_t pid;
        sem_t *sem_id = NULL;

        sem_id = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);

        sem_init(sem_id, 1, 1);

        pid = fork();

        if(pid > 0)
        {
                while(1)
                {
                        sem_wait(sem_id);
                        printf("Parent process.\n");
                        sleep(1);
                }
        }
        else if(pid == 0)
        {
                while(1)
                {
                        printf("Chiled process.\n");
                        sem_post(sem_id);
                        sleep(5);
                }
        }
        else
                perror("fork.");


        return 0;
}

​ 运行结果：

图1 运行结果

10.7 线程间信号量同步

​ sem_init()函数的原型如下，int sem_init(sem_t *sem, int pshared, unsigned int value);其中第二个参数pshared，它决定了这个初始化的信号量是在进程的线程之间还是两个进程之间。当pshared = 0时，初始化创建的信号量在线程之间，因为线程之间资源是共享的，所以这个信号量的地址只需要是一个全局变量即可，不在需要mmap()函数去创建映射。

​ 创建两个线程，线程1等待信号量，然后打印字符串“thread_1”，线程2每隔3秒打印字符串并且发布一个信号量。程序预期结果是，每隔3秒，线程2发布信号量后线程1才执行。

#include <pthread.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <semaphore.h>
#include <stdlib.h>

void *thread_fun1(void *arg);
void *thread_fun2(void *arg);

sem_t sem_id;

int main(void)
{

        int ret = 0;
        pthread_t thread1;
        pthread_t thread2;

        sem_init(&sem_id, 0, 0);

        ret |= pthread_create(&thread1, NULL, thread_fun1, NULL);

        if(0 != ret)
        {
                perror("thread_create.");
                exit(1);
        }

        ret |= pthread_create(&thread2, NULL, thread_fun2, NULL);

        if(0 != ret)
        {
                perror("thread_create.");
                exit(1);
        }

        pthread_join(thread1, NULL);
        pthread_join(thread2, NULL);

        return 0;
}

void *thread_fun1(void *arg)
{
        while(1)
        {
                sem_wait(&sem_id);
                printf("thread1.\n");
        }
}

void *thread_fun2(void *arg)
{
        while(1)
        {
                sem_post(&sem_id);
                printf("thread2.\n");
                sleep(3);
        }
}

​ 运行结果：

图2 运行结果

​ 程序运行开始，几乎同时打印出了thread1.与thread2.。然后每隔3秒钟同时打印出字符串。

10.8 命名信号量

​ 上面的无名信号量用于父子进程之间，而两个具有非亲缘关系进程之间同步使用的是命名信号量。命名信号量创建使用的是sem_open()函数。

NAME
       sem_open - initialize and open a named semaphore

SYNOPSIS
       #include <fcntl.h>           /* For O_* constants */
       #include <sys/stat.h>        /* For mode constants */
       #include <semaphore.h>

       sem_t *sem_open(const char *name, int oflag);
       sem_t *sem_open(const char *name, int oflag,
                       mode_t mode, unsigned int value);

       Link with -pthread.

​ 查看该函数的编程手册可知，sem_open()函数用来初始化并且打开一个命名信号量。使用时需要包含头文件fcntl.h与sys/stat.h与semaphore.h。函数原型如上图所示。编译时需要跟上-pthread。

ESCRIPTION
       sem_open()  creates  a  new POSIX semaphore or opens an existing semaphore.  The semaphore is identified by name.  For details of the construction of name, see sem_over‐
       view(7).

       The oflag argument specifies flags that control the operation of the call.  (Definitions of the flags values can be obtained by  including  <fcntl.h>.)   If  O_CREAT  is
       specified  in  oflag,  then  the  semaphore is created if it does not already exist.  The owner (user ID) of the semaphore is set to the effective user ID of the calling
       process.  The group ownership (group ID) is set to the effective group ID of the calling process.  If both O_CREAT and O_EXCL are specified in oflag, then  an  error  is
       returned if a semaphore with the given name already exists.

       If  O_CREAT is specified in oflag, then two additional arguments must be supplied.  The mode argument specifies the permissions to be placed on the new semaphore, as for
       open(2).  (Symbolic definitions for the permissions bits can be obtained by including <sys/stat.h>.)  The permissions settings are  masked  against  the  process  umask.
       Both  read and write permission should be granted to each class of user that will access the semaphore.  The value argument specifies the initial value for the new sema‐
       phore.  If O_CREAT is specified, and a semaphore with the given name already exists, then mode and value are ignored.

​ 调用sem_open()创建了一个新的信号量，或者打开已经存在的这个信号量。而这个信号量的标识符就是name这个参数，是一个字符串。参数oflag是一个位掩码，可以写入O_CREAT、 O_EXCL。如果oflag指定O_CREAT,并且指定name的信号量不存在，则创建一个新的信号量。如果oflag同时指定O_CREAT与O_EXCL，并且指定name的信号量已经存在，则sem_open()失败。

​ 如果sem_open()被用来打开一个已经存在的信号量，则调用只需要两个参数。(sem_t *sem_open(const char *name, int oflag);)如果oflag指定了O_CREAT，则还需要mode与value参数。mode也是一个位掩码(可以理解为宏定义在某个头文件)决定了新信号量的权限，只读、只写还是可读可写。一般来说，创建信号量后，后面会用到sem_wait()与sem_post(),需要开启读写权限。value是一个无符号整数，指定了信号量的初值。

​ 不管是创建一个新的信号量还是打开一个已经存在的信号量，sem_open()都会返回一个sem_t的指针，后续操作都是通过这个指针。调用失败则返回SEM_FAILED。

10.9 非亲缘进程之间通过命名信号量同步

​ 创建两个无关进程1和2，在进程1中创建一个新的命名信号量，name参数填入：“NAMED_SEM”。在while(1)中循环等待信号量，并且打印i++。在进程2中，打开之前创建的命名信号量，每隔1秒钟在while(1)中发布一个信号量并且打印i++。

​ named_sem1.c

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>

int main(void)
{
        int i = 0;
        sem_t *sem_id = NULL;

        sem_id = sem_open("Named_sem", O_CREAT, O_RDWR, 0);

        if(SEM_FAILED == sem_id)
                perror("sem_open.");

        while(1)
        {
                sem_wait(sem_id);
                printf("Process 1, i = %d.\n", i++);
        }

        sem_close(sem_id);

        return 0;
}

​ named_sem2.c

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <unistd.h>

int main(void)
{
        int i = 0;
        sem_t *sem_id = NULL;

        sem_id = sem_open("Named_sem", O_CREAT);

        while(1)
        {
                sem_post(sem_id);
                printf("Process 2, i = %d.\n", i++);
                sleep(1);
        }

        sem_close(sem_id);

        return 0;
}

​ 运行进程1，由于有名信号量初始值==0，所以进程1被阻塞。运行进程2，进程2中发布信号量，进程1也开始执行打印。最后的效果是，进程2执行，进程1也执行。

图3 运行结果

10.10 总结

​ 信号量用于任务间的同步，它本质是是一个整数被内核管理。具有亲缘关系的进程之间可以使用匿名信号量进行任务同步，非亲缘关系的进程之间使用有名信号量进行同步。