Linux进程同步之POSIX信号量

时间  2019-12-12 标签 linux 进程 同步 posix 信号

原文地址： http://blog.csdn.net/anonymalias/article/details/9219945ios


POSIX信号量是属于POSIX标准系统接口定义的实时扩展部分。在SUS（Single UNIX Specification）单一规范中，定义的XSI IPC中也一样定义了人们一般称为System V信号量的系统接口。信号量做为进程间同步的工具是很经常使用的一种同步IPC类型。编程

在《UNIX网络编程 卷2：进程间通讯》的前言第二页与第1版的区别中做者提到“POSIX IPC函数时大势所趋，由于他们比System V中的相应部分更具备优点”，这里所说的优点我还得慢慢领会呀。。。<T_T>安全

信号量是一种用于不一样进程间进行同步的工具，固然对于进程安全的对于线程也确定是安全的，因此信号量也理所固然能够用于同一进程内的不一样线程的同步。网络

有了互斥量和条件变量还提供信号量的缘由是：信号量的主要目的是提供一种进程间同步的方式。这种同步的进程能够共享也能够不共享内存区。虽然信号量的意图在于进程间的同步，互斥量和条件变量的意图在于线程间同步，但信号量也可用于线程间同步，互斥量和条件变量也可经过共享内存区进行进程间同步。但应该根据具体应用考虑到效率和易用性进行具体的选择。app

1 POSIX信号量的操做

POSIX信号量有两种：有名信号量和无名信号量，无名信号量也被称做基于内存的信号量。有名信号量经过IPC名字进行进程间的同步，而无名信号量若是不是放在进程间的共享内存区中，是不能用来进行进程间同步的，只能用来进行线程同步。ide

POSIX信号量有三种操做：函数

（1）建立一个信号量。建立的过程还要求初始化信号量的值。工具

根据信号量取值（表明可用资源的数目）的不一样，POSIX信号量还能够分为：post

  • 二值信号量：信号量的值只有0和1，这和互斥量很类型，若资源被锁住，信号量的值为0，若资源可用，则信号量的值为1；
  • 计数信号量：信号量的值在0到一个大于1的限制值（POSIX指出系统的最大限制值至少要为32767）。该计数表示可用的资源的个数。

（2）等待一个信号量（wait）。该操做会检查信号量的值，若是其值小于或等于0，那就阻塞，直到该值变成大于0，而后等待进程将信号量的值减1，进程得到共享资源的访问权限。这整个操做必须是一个原子操做。该操做还常常被称为P操做（荷兰语Proberen，意为：尝试）。测试

（3）挂出一个信号量（post）。该操做将信号量的值加1，若是有进程阻塞着等待该信号量，那么其中一个进程将被唤醒。该操做也必须是一个原子操做。该操做还常常被称为V操做（荷兰语Verhogen，意为：增长）

下面演示经典的生产者消费者问题，单个生产者和消费者共享一个缓冲区；

下面是生产者和消费者同步的伪代码：


[cpp]  view plain copy print ?
  1. //信号量的初始化  
  2. get = 0;//表示可读资源的数目  
  3. put = 1;//表示可写资源的数目  
  4.   
  5. //生产者进程                               //消费者进程  
  6. for(; ;){                                    for(; ;){  
  7. Sem_wait(put);                                 Sem_wait(get);  
  8. 写共享缓冲区；                               读共享缓冲区；  
  9. Sem_post(get);                                 Sem_post(put);  
  10. }                                           }  
上面的代码大体流程以下：当生产者和消费者开始都运行时，生产者获取put 信号量，此时 put 为 1 表示有资源可用，生产者进入共享缓冲区，进行修改。而消费者获取 get 信号量，而此时 get 为 0 ，表示没有资源可读，因而消费者进入等待序列，直到生产者生产出一个数据，而后生产者经过挂出 get 信号量来通知等待的消费者，有数据能够读。

不少时候信号量和互斥量，条件变量三者均可以在某种应用中使用，那这三者的差别有哪些呢，下面列出了这三者之间的差别：

  • 互斥量必须由给它上锁的线程解锁。而信号量不须要由等待它的线程进行挂出，能够在其余进程进行挂出操做。
  • 互斥量要么被锁住，要么是解开状态，只有这两种状态。而信号量的值能够支持多个进程成功进行wait操做。
  • 信号量的挂出操做老是被记住，由于信号量有一个计数值，挂出操做总会将该计数值加1，然而当向条件变量发送一个信号时，若是没有线程等待在条件变量，那么该信号会丢失。

2 POSIX信号量函数接口

POSIX信号量的函数接口以下图所示：


2.1有名信号量的建立和删除

[cpp]  view plain copy print ?
  1. #include <semaphore.h>  
  2.   
  3. sem_t *sem_open(const char *name, int oflag);  
  4. sem_t *sem_open(const char *name, int oflag,  
  5.                   mode_t mode, unsigned int value);  
  6.                               //成功返回信号量指针，失败返回SEM_FAILED  

sem_open用于建立或打开一个信号量，信号量是经过name参数即信号量的名字来进行标识的。关于POSX IPC的名字能够参考《UNIX网络编程 卷2：进程间通讯》P14。

oflag参数能够为：0，O_CREAT，O_EXCL。若是为0表示打开一个已存在的信号量，若是为O_CREAT，表示若是信号量不存在就建立一个信号量，若是存在则打开被返回。此时mode和value须要指定。若是为O_CREAT | O_EXCL，表示若是信号量已存在会返回错误。

mode参数用于建立信号量时，表示信号量的权限位，和open函数同样包括：S_IRUSR，S_IWUSR，S_IRGRP，S_IWGRP，S_IROTH，S_IWOTH。

value表示建立信号量时，信号量的初始值。

[cpp]  view plain copy print ?
  1. #include <semaphore.h>  
  2.   
  3. int sem_close(sem_t *sem);  
  4. int sem_unlink(const char *name);  
  5.                               //成功返回0，失败返回-1  

sem_close用于关闭打开的信号量。当一个进程终止时，内核对其上仍然打开的全部有名信号量自动执行这个操做。调用sem_close关闭信号量并无把它从系统中删除它，POSIX有名信号量是随内核持续的。即便当前没有进程打开某个信号量它的值依然保持。直到内核从新自举或调用sem_unlink()删除该信号量。

sem_unlink用于将有名信号量马上从系统中删除，但信号量的销毁是在全部进程都关闭信号量的时候。

2.2信号量的P操做

[cpp]  view plain copy print ?
  1. #include <semaphore.h>  
  2.   
  3. int sem_wait (sem_t *sem);  
  4.   
  5. #ifdef __USE_XOPEN2K  
  6. int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);  
  7. #endif  
  8.   
  9. int sem_trywait (sem_t * sem);  
  10.                               //成功返回0，失败返回-1  
sem_wait() 用于获取信号量，首先会测试指定信号量的值，若是大于 0 ，就会将它减 1 并当即返回，若是等于 0 ，那么调用线程会进入睡眠，指定信号量的值大于 0.

sem_trywait和sem_wait的差异是，当信号量的值等于0的，调用线程不会阻塞，直接返回，并标识EAGAIN错误。

sem_timedwait和sem_wait的差异是当信号量的值等于0时，调用线程会限时等待。当等待时间到后，信号量的值仍是0，那么就会返回错误。其中 struct timespec *abs_timeout是一个绝对时间，具体能够参考条件变量关于等待时间的使用

2.3信号量的V操做
[cpp]  view plain copy print ?
  1. #include <semaphore.h>  
  2.   
  3. int sem_post(sem_t *sem);  
  4.                             //成功返回0，失败返回-1  

当一个线程使用完某个信号量后，调用sem_post，使该信号量的值加1，若是有等待的线程，那么会唤醒等待的一个线程。

2.4获取当前信号量的值
[cpp]  view plain copy print ?
  1. #include <semaphore.h>  
  2.   
  3. int sem_getvalue(sem_t *sem,  int *sval);  
  4.                             //成功返回0，失败返回-1  

该函数返回当前信号量的值，经过sval输出参数返回，若是当前信号量已经上锁（即同步对象不可用），那么返回值为0，或为负数，其绝对值就是等待该信号量解锁的线程数。

下面测试在Linux下的信号量是否会出现负值：

[cpp]  view plain copy print ?
  1. #include <iostream>  
  2.   
  3. #include <unistd.h>  
  4. #include <semaphore.h>  
  5. #include <fcntl.h>  
  6.   
  7. using namespace std;  
  8.   
  9. #define SEM_NAME "/sem_name"  
  10.   
  11. sem_t *pSem;  
  12.   
  13. void * testThread (void *ptr)  
  14. {  
  15.     sem_wait(pSem);  
  16.     sleep(10);  
  17.     sem_close(pSem);  
  18. }  
  19.   
  20. int main()  
  21. {  
  22.     pSem = sem_open(SEM_NAME, O_CREAT, 0666, 5);  
  23.   
  24.     pthread_t pid;  
  25.     int semVal;  
  26.   
  27.     for (int i = 0; i < 7; ++i)  
  28.     {  
  29.         pthread_create(&pid, NULL, testThread, NULL);  
  30.   
  31.         sleep(1);  
  32.   
  33.         sem_getvalue(pSem, &semVal);   
  34.         cout<<"semaphore value:"<<semVal<<endl;  
  35.     }  
  36.   
  37.     sem_close(pSem);  
  38.     sem_unlink(SEM_NAME);  
  39. }  

执行结果以下：

[cpp]  view plain copy print ?
  1. semaphore value:4  
  2. semaphore value:3  
  3. semaphore value:2  
  4. semaphore value:1  
  5. semaphore value:0  
  6. semaphore value:0  
  7. semaphore value:0  

这说明在Linux 2.6.18中POSIX信号量是不会出现负值的。

2.5无名信号量的建立和销毁

[cpp]  view plain copy print ?
  1. #include <semaphore.h>  
  2.   
  3. int sem_init(sem_t *sem, int pshared, unsigned int value);  
  4.                             //若出错则返回-1  
  5. int sem_destroy(sem_t *sem);  
  6.                             //成功返回0，失败返回-1  

sem_init()用于无名信号量的初始化。无名信号量在初始化前必定要在内存中分配一个sem_t信号量类型的对象，这就是无名信号量又称为基于内存的信号量的缘由。

sem_init()第一个参数是指向一个已经分配的sem_t变量。第二个参数pshared表示该信号量是否因为进程间通步，当pshared = 0，那么表示该信号量只能用于进程内部的线程间的同步。当pshared != 0，表示该信号量存放在共享内存区中，使使用它的进程可以访问该共享内存区进行进程同步。第三个参数value表示信号量的初始值。

这里须要注意的是，无名信号量不使用任何相似O_CREAT的标志，这表示sem_init()老是会初始化信号量的值，因此对于特定的一个信号量，咱们必须保证只调用sem_init()进行初始化一次，对于一个已初始化过的信号量调用sem_init()的行为是未定义的。若是信号量尚未被某个线程调用还好，不然基本上会出现问题。

使用完一个无名信号量后，调用sem_destroy摧毁它。这里要注意的是：摧毁一个有线程阻塞在其上的信号量的行为是未定义的。

2.6有名和无名信号量的持续性

有名信号量是随内核持续的。当有名信号量建立后，即便当前没有进程打开某个信号量它的值依然保持。直到内核从新自举或调用sem_unlink()删除该信号量。

无名信号量的持续性要根据信号量在内存中的位置：

  • 若是无名信号量是在单个进程内部的数据空间中，即信号量只能在进程内部的各个线程间共享，那么信号量是随进程的持续性，当进程终止时它也就消失了。
  • 若是无名信号量位于不一样进程的共享内存区，所以只要该共享内存区仍然存在，该信号量就会一直存在。因此此时无名信号量是随内核的持续性。

2.7信号量的继承和销毁

（1）继承

对于有名信号量在父进程中打开的任何有名信号量在子进程中还是打开的。即下面代码是正确的：

[cpp]  view plain copy print ?
  1. sem_t *pSem;  
  2. pSem = sem_open(SEM_NAME, O_CREAT, 0666, 5);  
  3.   
  4. if(fork() == 0)  
  5. {  
  6.     //...  
  7.     sem_wait(pSem);  
  8.     //...  
  9. }  

对于无名信号量的继承要根据信号量在内存中的位置：

  • 若是无名信号量是在单个进程内部的数据空间中，那么信号量就是进程数据段或者是堆栈上，当fork产生子进程后，该信号量只是原来的一个拷贝，和以前的信号量是独立的。下面是测试代码：

[cpp]  view plain copy print ?
  1. int main()  
  2. {  
  3.     sem_t mSem;  
  4.     sem_init(&mSem, 0, 3);  
  5.   
  6.     int val;  
  7.     sem_getvalue(&mSem, &val);  
  8.     cout<<"parent:semaphore value:"<<val<<endl;  
  9.   
  10.     sem_wait(&mSem);  
  11.     sem_getvalue(&mSem, &val);  
  12.     cout<<"parent:semaphore value:"<<val<<endl;  
  13.   
  14.     if(fork() == 0)  
  15.     {     
  16.         sem_getvalue(&mSem, &val);  
  17.         cout<<"child:semaphore value:"<<val<<endl;    
  18.   
  19.         sem_wait(&mSem);  
  20.   
  21.         sem_getvalue(&mSem, &val);  
  22.         cout<<"child:semaphore value:"<<val<<endl;  
  23.   
  24.         exit(0);  
  25.     }  
  26.     sleep(1);  
  27.   
  28.     sem_getvalue(&mSem, &val);  
  29.     cout<<"parent:semaphore value:"<<val<<endl;  
  30. }  

测试结果以下：

[cpp]  view plain copy print ?
  1. parent:semaphore value:3  
  2. parent:semaphore value:2  
  3. child:semaphore value:2  
  4. child:semaphore value:1  
  5. parent:semaphore value:2  
  • 若是无名信号量位于不一样进程的共享内存区，那么fork产生的子进程中的信号量仍然会存在该共享内存区，因此该信号量仍然保持着以前的状态。

（2）销毁

对于有名信号量，当某个持有该信号量的进程没有解锁该信号量就终止了，内核并不会将该信号量解锁。这跟记录锁不同。

对于无名信号量，若是信号量位于进程内部的内存空间中，当进程终止后，信号量也就不存在了，无所谓解锁了。若是信号量位于进程间的共享内存区中，当进程终止后，内核也不会将该信号量解锁。

下面是测试代码：

[cpp]  view plain copy print ?
  1. int main()  
  2. {  
  3.     sem_t *pSem;  
  4.     pSem = sem_open(SEM_NAME, O_CREAT, 0666, 5);  
  5.   
  6.     int val;  
  7.     sem_getvalue(pSem, &val);  
  8.     cout<<"parent:semaphore value:"<<val<<endl;     
  9.   
  10.     if(fork() == 0)  
  11.     {     
  12.         sem_wait(pSem);  
  13.         sem_getvalue(pSem, &val);  
  14.         cout<<"child:semaphore value:"<<val<<endl;  
  15.   
  16.         exit(0);  
  17.     }  
  18.     sleep(1);  
  19.   
  20.     sem_getvalue(pSem, &val);  
  21.     cout<<"parent:semaphore value:"<<val<<endl;  
  22.   
  23.     sem_unlink(SEM_NAME);  
  24. }  

下面是测试结果：

[cpp]  view plain copy print ?
  1. parent:semaphore value:5  
  2. child:semaphore value:4  
  3. parent:semaphore value:4  

2.8信号量代码测试

对于有名信号量在父进程中打开的任何有名信号量在子进程中还是打开的。即下面代码是正确的：

对于信号量用于进程间同步的代码的测试，我没有采用经典的生产者和消费者问题，缘由是这里会涉及到共享内存的操做。我只是简单的用一个同步文件操做的例子进行描述。 在下面的测试代码中，POSIX有名信号量初始值为2，容许两个进程得到文件的操做权限。代码以下：

[cpp]  view plain copy print ?
  1. #include <iostream>  
  2. #include <fstream>  
  3. #include <cstdlib>  
  4.   
  5. #include <unistd.h>  
  6. #include <semaphore.h>  
  7. #include <fcntl.h>  
  8.   
  9. using namespace std;  
  10.   
  11. #define SEM_NAME "/sem_name"  
  12.   
  13. void semTest(int flag)  
  14. {   
  15.     sem_t *pSem;  
  16.     pSem = sem_open(SEM_NAME, O_CREAT, 0666, 2);  
  17.   
  18.     sem_wait(pSem);  
  19.   
  20.     ofstream fileStream("./test.txt", ios_base::app);    
  21.   
  22.     for (int i = 0; i < 5; ++i)    
  23.     {    
  24.         sleep(1);    
  25.   
  26.         fileStream<<flag;    
  27.         fileStream<<' '<<flush;    
  28.     }    
  29.   
  30.     sem_post(pSem);  
  31.     sem_close(pSem);  
  32. }  
  33.   
  34. int main()  
  35. {  
  36.    for (int i = 1; i <= 3; ++i)  
  37.    {  
  38.        if (fork() == 0)  
  39.        {  
  40.            semTest(i);  
  41.   
  42.            sleep(1);  
  43.            exit(0);  
  44.        }  
  45.    }  
  46. }  

程序的运行结果，“./test.txt”文件的内容以下：

[cpp]  view plain copy print ?
  1. //./test.txt  
  2. 1 2 1 2 1 2 1 2 1 2 3 3 3 3 3     
联系我们 沪ICP备13005482号-10