有N个进程共享同一临界资源，如用信号量机制，实现对一临界资源的互斥访问，则信号量的变化范围是？

Posted 2023-04-21

A：1----N B：1----(-N) C：1----(N-1) D：1----[-(n-1)]
为什么选C？

D：1－－－－［－（n－1）］信号量初值为1．当有进程运行时，其他进程访问信号量，信号量就会减一。

信号量是指同时需要多个资源且每种占用一个资源时的信号量操作。即在一个原语中申请整段代码度需要的多个临界资源，要么全部分配给它，要么一个都不分配给它。

以避免当一段处理代码需要同时获取两个或多个临界资问源时，出现由于各进程等待其余的临界资源，变成死锁的情况。

扩展资料：

注意事项：

信号响应，每个信号的顺序并不重要，虽然会影响块队列的过程，但由于原子操作模式，是否所有分配的资源分配，所以总有一个过程的所有资源和释放资源推动后，所以它不会死锁。

由于在信号量和信号量中使用通用信号的灵活性，Swait和Ssignal通常不成对使用。为了避免死锁，可以一起申请所有需要的资源，但不要一起释放它们。

信号量是指进程在执行任务之前需要获取两个或多个共享资源的应用程序。

假设现在有两个进程A和B，它们都需要访问共享数据D和e。当然，共享数据应该始终是关键资源。

为此可以将信号量Dmutex和Emutex分别设置为互斥，并将它们的初始值设置为1，因此个进程都包含了对Dmutex和Emutex的操作。

参考技术A 答案为D，信号量初值为1.当有进程运行时，其他进程访问信号量，信号量就会减一本回答被提问者采纳 参考技术B D 。当没有进程使用时是1 且最多是1.
当有进程申请时便减1 第一个申请是0 第二个是-1 类推可得D 参考技术C 选C

进程间通信四（信号量）

1.什么是信号量？

　　为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码需要独占式地执行。而信号量就可以提供这样的一种访问机制，让一个临界区同一时间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。

　　信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，叫做二进制信号量。而可以取多个正整数的信号量被称为通用信号量。这里主要讨论二进制信号量。

 

2.信号量的工作原理

由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：

P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行

V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1.

 

举个例子，就是两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减1。而第二个进程将被阻止进入临界区，因为当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行。

 

3. Linux的信号量机制

Linux提供了一组精心设计的信号量接口来对信号进行操作，它们不只是针对二进制信号量，下面将会对这些函数进行介绍，但请注意，这些函数都是用来对成组的信号量值进行操作的。它们声明在头文件sys/sem.h中。

 

3.1 semget函数

它的作用是创建一个新信号量或取得一个已有信号量，原型为：

int semget(key_t key, int num_sems, int sem_flags);  

第一个参数key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget函数并提供一个键，再由系统生成一个相应的信号标识符（semget函数的返回值），只有semget函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。

 

第二个参数num_sems指定需要的信号量数目，它的值几乎总是1。

 

第三个参数sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。

 

semget函数成功返回一个相应信号标识符（非零），失败返回-1.

 

3.2 semop函数

它的作用是改变信号量的值，原型为：

int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);  

 

sem_id是由semget返回的信号量标识符，sembuf结构的定义如下：

struct sembuf{  

 　　　　　　　  short sem_num;　　　　　　　　　　//除非使用一组信号量，否则它为0  

　　　　　　　　short sem_op;　　　　　　　　　　　//信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即P（等待）操作，一个是+1，即V（发送信号）操作。  

　　　　　　　　short sem_flg;　　　　　　　　　　　//通常为SEM_UNDO,使操作系统跟踪信号，并在进程没有释放该信号量而终止时，操作系统释放信号量  

　　　　　　　　};  

3.3 semctl函数

该函数用来直接控制信号量信息，它的原型为：

int semctl(int sem_id, int sem_num, int command, ...);  

 

如果有第四个参数，它通常是一个union semum结构，定义如下：

union semun{  

　　　　　　　　int val;  

　　　　　　　　struct semid_ds *buf;  

 　　　　　　　　 unsigned short *arry;  

　　　　　　　};  

前两个参数与前面一个函数中的一样，command通常是下面两个值中的其中一个

SETVAL：用来把信号量初始化为一个已知的值。p 这个值通过union semun中的val成员设置，其作用是在信号量第一次使用前对它进行设置。

IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。

 

4.进程使用信号量通信

　　下面使用一个例子来说明进程间如何使用信号量来进行通信，这个例子是两个相同的程序同时向屏幕输出数据，我们可以看到如何使用信号量来使两个进程协调工作，使同一时间只有一个进程可以向屏幕输出数据。注意，如果程序是第一次被调用（为了区分，第一次调用程序时带一个要输出到屏幕中的字符作为一个参数），则需要调用set_semvalue函数初始化信号并将message字符设置为传递给程序的参数的第一个字符，同时第一个启动的进程还负责信号量的删除工作。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

 

在main函数中调用semget来创建一个信号量，该函数将返回一个信号量标识符，保存于全局变量sem_id中，然后以后的函数就使用这个标识符来访问信号量。

 

源文件为semaphore.c，代码如下：

 

1. #include <unistd.h>  
2. #include <sys/types.h>  
3. #include <sys/stat.h>  
4. #include <fcntl.h>  
5. #include <stdlib.h>  
6. #include <stdio.h>  
7. #include <string.h>  
8. #include <sys/sem.h>  
9.   
10. union semun  
11. {  
12.     int val;  
13.     struct semid_ds *buf;  
14.     unsigned short *arry;  
15. };  
16.   
17. static int sem_id = 0;  
18.   
19. static int set_semvalue();  
20. static void del_semvalue();  
21. static int semaphore_p();  
22. static int semaphore_v();  
23.   
24. int main(int argc, char *argv[])  
25. {  
26.     char message = ‘X‘;  
27.     int i = 0;  
28.   
29.     //创建信号量  
30.     sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);  
31.   
32.     if(argc > 1)  
33.     {  
34.         //程序第一次被调用，初始化信号量  
35.         if(!set_semvalue())  
36.         {  
37.             fprintf(stderr, "Failed to initialize semaphore\n");  
38.             exit(EXIT_FAILURE);  
39.         }  
40.         //设置要输出到屏幕中的信息，即其参数的第一个字符  
41.         message = argv[1][0];  
42.         sleep(2);  
43.     }  
44.     for(i = 0; i < 10; ++i)  
45.     {  
46.         //进入临界区  
47.         if(!semaphore_p())  
48.             exit(EXIT_FAILURE);  
49.         //向屏幕中输出数据  
50.         printf("%c", message);  
51.         //清理缓冲区，然后休眠随机时间  
52.         fflush(stdout);  
53.         sleep(rand() % 3);  
54.         //离开临界区前再一次向屏幕输出数据  
55.         printf("%c", message);  
56.         fflush(stdout);  
57.         //离开临界区，休眠随机时间后继续循环  
58.         if(!semaphore_v())  
59.             exit(EXIT_FAILURE);  
60.         sleep(rand() % 2);  
61.     }  
62.   
63.     sleep(10);  
64.     printf("\n%d - finished\n", getpid());  
65.   
66.     if(argc > 1)  
67.     {  
68.         //如果程序是第一次被调用，则在退出前删除信号量  
69.         sleep(3);  
70.         del_semvalue();  
71.     }  
72.     exit(EXIT_SUCCESS);  
73. }  
74.   
75. static int set_semvalue()  
76. {  
77.     //用于初始化信号量，在使用信号量前必须这样做  
78.     union semun sem_union;  
79.   
80.     sem_union.val = 1;  
81.     if(semctl(sem_id, 0, SETVAL, sem_union) == -1)  
82.         return 0;  
83.     return 1;  
84. }  
85.   
86. static void del_semvalue()  
87. {  
88.     //删除信号量  
89.     union semun sem_union;  
90.   
91.     if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1)  
92.         fprintf(stderr, "Failed to delete semaphore\n");  
93. }  
94.   
95. static int semaphore_p()  
96. {  
97.     //对信号量做减1操作，即等待P（sv）  
98.     struct sembuf sem_b;  
99.     sem_b.sem_num = 0;  
100.     sem_b.sem_op = -1;//P()  
101.     sem_b.sem_flg = SEM_UNDO;  
102.     if(semop(sem_id, &sem_b, 1) == -1)  
103.     {  
104.         fprintf(stderr, "semaphore_p failed\n");  
105.         return 0;  
106.     }  
107.     return 1;  
108. }  
109.   
110. static int semaphore_v()  
111. {  
112.     //这是一个释放操作，它使信号量变为可用，即发送信号V（sv）  
113.     struct sembuf sem_b;  
114.     sem_b.sem_num = 0;  
115.     sem_b.sem_op = 1;//V()  
116.     sem_b.sem_flg = SEM_UNDO;  
117.     if(semop(sem_id, &sem_b, 1) == -1)  
118.     {  
119.         fprintf(stderr, "semaphore_v failed\n");  
120.         return 0;  
121.     }  
122.     return 1;  
123. }  

运行结果如下：

[[email protected] program1]$ls
semaphore.c
[[email protected] program1]$gcc semaphore.c -o semaphore
[[email protected] program1]$./semaphore 0 & ./semaphore
[1] 3505
XXXX00XX00XX00XXXX00XX00XX00XXXX00000000
3506 - finished
[[email protected] program1]$
3505 - finished

[1]+ Done ./semaphore 0
[[email protected] program1]$

 

注：这个程序的临界区为main函数for循环不的semaphore_p和semaphore_v函数中间的代码。

 

例子分析 ：

　　同时运行一个程序的两个实例，注意第一次运行时，要加上一个字符作为参数，例如本例中的字符‘O’，它用于区分是否为第一次调用，同时这个字符输出到屏幕中。因为每个程序都在其进入临界区后和离开临界区前打印一个字符，所以每个字符都应该成对出现，正如你看到的上图的输出那样。在main函数中循环中我们可以看到，每次进程要访问stdout（标准输出），即要输出字符时，每次都要检查信号量是否可用（即stdout有没有正在被其他进程使用）。所以，当一个进程A在调用函数semaphore_p进入了临界区，输出字符后，调用sleep时，另一个进程B可能想访问stdout，但是信号量的P请求操作失败，只能挂起自己的执行，当进程A调用函数semaphore_v离开了临界区，进程B马上被恢复执行。然后进程A和进程B就这样一直循环了10次。

 

 

5.信号量的总结

　　信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。我们通常通过信号来解决多个进程对同一资源的访问竞争的问题，使在任一时刻只能有一个执行线程访问代码的临界区域，也可以说它是协调进程间的对同一资源的访问权，也就是用于同步进程的。

　　信号量的意图在于进程间同步，互斥锁和条件变量的意图则在于线程间同步。但是信号量也可用于线程间，互斥锁和条件变量也可用于进程间

 

原文：http://blog.csdn.net/ljianhui/article/details/10243617