當前位置：GoMCU > 未分類 > 正文

[轉] Linux进程同步之POSIX信号量

2013-11-12 分類：未分類 評論(0)

出處：http://blog.csdn.net/anonymalias/article/details/9219945

POSIX信号量是属于POSIX标准系统接口定义的实时扩展部分。在SUS（Single UNIX Specification）单一规范中，定义的XSI IPC中也同样定义了人们通常称为System V信号量的系统接口。信号量作为进程间同步的工具是很常用的一种同步IPC类型。
在《UNIX网络编程 卷2：进程间通信》的前言第二页与第1版的区别中作者提到“POSIX IPC函数时大势所趋，因为他们比System V中的相应部分更具有优势”，这里所说的优势我还得慢慢领会呀。。。<T_T>
信号量是一种用于不同进程间进行同步的工具，当然对于进程安全的对于线程也肯定是安全的，所以信号量也理所当然可以用于同一进程内的不同线程的同步。
有了互斥量和条件变量还提供信号量的原因是：信号量的主要目的是提供一种进程间同步的方式。这种同步的进程可以共享也可以不共享内存区。虽然信号量的意图在于进程间的同步，互斥量和条件变量的意图在于线程间同步，但信号量也可用于线程间同步，互斥量和条件变量也可通过共享内存区进行进程间同步。但应该根据具体应用考虑到效率和易用性进行具体的选择。

1 POSIX信号量的操作

POSIX信号量有两种：有名信号量和无名信号量，无名信号量也被称作基于内存的信号量。有名信号量通过IPC名字进行进程间的同步，而无名信号量如果不是放在进程间的共享内存区中，是不能用来进行进程间同步的，只能用来进行线程同步。
POSIX信号量有三种操作：
（1）创建一个信号量。创建的过程还要求初始化信号量的值。
根据信号量取值（代表可用资源的数目）的不同，POSIX信号量还可以分为：
  • 二值信号量：信号量的值只有0和1，这和互斥量很类型，若资源被锁住，信号量的值为0，若资源可用，则信号量的值为1；
  • 计数信号量：信号量的值在0到一个大于1的限制值（POSIX指出系统的最大限制值至少要为32767）。该计数表示可用的资源的个数。
（2）等待一个信号量（wait）。该操作会检查信号量的值，如果其值小于或等于0，那就阻塞，直到该值变成大于0，然后等待进程将信号量的值减1，进程获得共享资源的访问权限。这整个操作必须是一个原子操作。该操作还经常被称为P操作（荷兰语Proberen，意为：尝试）。
（3）挂出一个信号量（post）。该操作将信号量的值加1，如果有进程阻塞着等待该信号量，那么其中一个进程将被唤醒。该操作也必须是一个原子操作。该操作还经常被称为V操作（荷兰语Verhogen，意为：增加）
下面演示经典的生产者消费者问题，单个生产者和消费者共享一个缓冲区；
下面是生产者和消费者同步的伪代码：
[cpp] view plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  1. #include <semaphore.h>  
  2.   
  3. int sem_post(sem_t *sem);  
  4.                             //成功返回0，失败返回-1  
当一个线程使用完某个信号量后，调用sem_post，使该信号量的值加1，如果有等待的线程，那么会唤醒等待的一个线程。
2.4获取当前信号量的值
[cpp] view plaincopy

  1. #include <semaphore.h>  
  2.   
  3. int sem_getvalue(sem_t *sem,  int *sval);  
  4.                             //成功返回0，失败返回-1  
该函数返回当前信号量的值，通过sval输出参数返回，如果当前信号量已经上锁（即同步对象不可用），那么返回值为0，或为负数，其绝对值就是等待该信号量解锁的线程数。
下面测试在Linux下的信号量是否会出现负值：
[cpp] view plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  1. parent:semaphore value:5  
  2. child:semaphore value:4  
  3. parent:semaphore value:4  

2.8信号量代码测试

对于有名信号量在父进程中打开的任何有名信号量在子进程中仍是打开的。即下面代码是正确的：
对于信号量用于进程间同步的代码的测试，我没有采用经典的生产者和消费者问题，原因是这里会涉及到共享内存的操作。我只是简单的用一个同步文件操作的例子进行描述。 在下面的测试代码中，POSIX有名信号量初始值为2，允许两个进程获得文件的操作权限。代码如下：
[cpp] view plaincopy

  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 plaincopy

  1. //./test.txt  
  2. 1 2 1 2 1 2 1 2 1 2 3 3 3 3 3     

未經允許不得轉載：GoMCU » [轉] Linux进程同步之POSIX信号量
標籤：

相關推薦