linux PV操作理解

妖狐艹你老母 2022-08-20 13:16 294阅读 0赞

进程通常分为就绪、运行和阻塞三个工作状态。三种状态在某些条件下可以转换，三者之间的转换关系如下：

![1350289195_2087.jpg][]

进程三个状态之间的转换就是靠PV操作来控制的。PV操作主要就是P操作、V操作和信号量。其中信号量起到了至关重要的作用。

**信号量**

信号量是最早出现的用来解决进程同步与互斥问题的机制。

信号量（Saphore）由一个值和一个指针组成，指针指向等待该信号量的进程。信号量的值表示相应资源的使用情况。信号量S>=0时，S表示可用资源的数量。执行一次P操作意味着请求分配一个资源，因此S的值减1；当S<0时，表示已经没有可用资源，S的绝对值表示当前等待该资源的进程数。请求者必须等待其他进程释放该类资源，才能继续运行。而执行一个V操作意味着释放一个资源，因此S的值加1；若S<0，表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。

注意，信号量的值只能由PV操作来改变。

**关于PV操作容易产生的一些疑问：**

**1，S大于0那就表示有临界资源可供使用，为什么不唤醒进程？**

S大于0的确表示有临界资源可供使用，也就是说这个时候没有进程被阻塞在这个资源上，所以不需要唤醒。

**2，S小于0应该是说没有临界资源可供使用，为什么还要唤醒进程？**

V原语操作的本质在于：一个进程使用完临界资源后，释放临界资源，使S加1，以通知其它的进程，这个时候如果S<0，表明有进程阻塞在该类资源上，因此要从阻塞队列里唤醒一个进程来“转手”该类资源。比如，有两个某类资源，四个进程A、B、C、D要用该类资源，最开始S=2，当A进入，S=1，当B进入S=0，表明该类资源刚好用完， 当C进入时S=-1，表明有一个进程被阻塞了，D进入，S=-2。当A用完该类资源时，进行V操作，S=-1，释放该类资源，因为S<0，表明有进程阻塞在该类资源上，于是唤醒一个。

**3，如果是互斥信号量的话，应该设置信号量S=1，但是当有5个进程都访问的话，最后在该信号量的链表里会有4个在等待，也是说S=-4，那么第一个进程执行了V操作使S加1，释放了资源，下一个应该能够执行，但唤醒的这个进程在执行P操作时因S<0，也还是执行不了，这是怎么回事呢？**

当一个进程阻塞了的时候，它已经执行过了P操作，并卡在临界区那个地方。当唤醒它时就立即进入它自己的临界区，并不需要执行P操作了，当执行完了临界区的程序后，就执行V操作。

**4，S的绝对值表示等待的进程数，同时又表示临界资源，这到底是怎么回事？**

当信号量S小于0时，其绝对值表示系统中因请求该类资源而被阻塞的进程数目.S大于0时表示可用的临界资源数。注意在不同情况下所表达的含义不一样。当等于0时，表示刚好用完。

关于pv操作部分的内容，其实算不上什么新的东西。但是它对于我们理解信号量、消息处理部分的工作还是有很大帮助的。之前我们给出了一个win32的处理方案，但是实现的比较草率。所以我们今天可以利用linux上的信号量函数把这个功能重新实现一遍。

**    （1）linux下面信号量的基本函数**

a）创建信号量  sem\_init

b）等待信号量 sem\_wait

c）释放信号量 sem\_pos

d）删除信号量 sem\_destroy

**    （2）编写pv操作函数**

之前在编写pv操作的时候，没有考虑到消息处理的时序问题，所以在某些极端的情况下可能会造成一些问题。所以本次pv操作采用了循环队列的形式，保持了消息的先后入队顺序。这样对于线程收到的各种消息就可以依次进行处理解决了。同样，我们文件编译的方法非常简单，shell下输入gcc sem.c -g -o sem -lpthread即可。

可能有同学会问，单独的循环队列和pv操作处理上有什么差别？其实差别很简单，pv可以是不同线程向一个线程发送消息，而循环队列只能接受一个线程发送的消息，否则处理上就麻烦了。

**\[cpp\]**  [view plain][]  [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <malloc.h>  
3.  \#include <string.h>  
4.  \#include <pthread.h>  
5.  \#include <semaphore.h>  
6.    
7.  **struct** MSG  
8.  \{  
9.      sem\_t s\_empty;  
10.     sem\_t s\_full;  
11.     sem\_t s\_msg;  
12.     **int**\* p\_buffer;  
13.     **int** start;  
14.     **int** end;  
15.     **int** count;  
16. \};  
17.   
18.   
19. \#define STATUS int  
20. \#define TRUE 1  
21. \#define FALSE 0  
22. **static** **struct** MSG\* p\_msg = NULL;  
23.   
24.   
25. **struct** MSG\* alloc\_msg(**int** count)  
26. \{  
27.     **struct** MSG\* p\_msg;  
28.     p\_msg = (**struct** MSG\*) malloc(**sizeof**(**struct** MSG));  
29.     **if**(NULL == p\_msg)  
30.     \{  
31.         **goto** error1;  
32.     \}  
33.     memset(p\_msg, 0, **sizeof**(**struct** MSG));     
34.     p\_msg->count = count;  
35.   
36.     p\_msg->p\_buffer = (**int**\*)malloc(**sizeof**(**int**)\* count);  
37.     **if**(NULL == p\_msg->p\_buffer)  
38.     \{  
39.         **goto** error2;  
40.     \}  
41.   
42.     sem\_init(&p\_msg->s\_empty, 0, count);  
43.     sem\_init(&p\_msg->s\_full, 0, 0);  
44.     sem\_init(&p\_msg->s\_msg, 0, 1);  
45.   
46.     **return** p\_msg;  
47.   
48. error2:  
49.     free(p\_msg);  
50.   
51. error1:  
52.     **return**;  
53. \}  
54.   
55.   
56. **void** del\_msg(**struct** MSG\* p\_msg)  
57. \{  
58.     **if**(p\_msg)  
59.     \{  
60.         **if**(p\_msg->p\_buffer)  
61.         \{  
62.             free(p\_msg->p\_buffer);  
63.         \}  
64.           
65.         sem\_destroy(&p\_msg->s\_msg);  
66.         sem\_destroy(&p\_msg->s\_full);  
67.         sem\_destroy(&p\_msg->s\_empty);  
68.         free(p\_msg);  
69.     \}  
70. \}  
71.   
72.   
73. STATUS put\_msg(**struct** MSG\* p\_msg, **int** data)  
74. \{  
75.     **if**(NULL == p\_msg )  
76.     \{  
77.         **return** FALSE;  
78.     \}  
79.   
80.     sem\_wait(&p\_msg->s\_empty);  
81.     sem\_wait(&p\_msg->s\_msg);  
82.     p\_msg->p\_buffer\[p\_msg->start\] = data;  
83.     p\_msg->start = (p\_msg->start + 1) % p\_msg->count;  
84.     sem\_post(&p\_msg->s\_msg);  
85.     sem\_post(&p\_msg->s\_full);  
86.   
87.     **return** TRUE;  
88. \}  
89.   
90.   
91. STATUS get\_msg(**struct** MSG\* p\_msg, **int**\* p\_buf)  
92. \{  
93.     **if**(NULL == p\_msg || NULL == p\_buf)  
94.     \{  
95.         **return** FALSE;  
96.     \}  
97.   
98.     sem\_wait(&p\_msg->s\_full);  
99.     sem\_wait(&p\_msg->s\_msg);  
100.     p\_buf\[0\] = p\_msg->p\_buffer\[p\_msg->end\];  
101.     p\_msg->end = (p\_msg->end + 1)% p\_msg->count;  
102.     sem\_post(&p\_msg->s\_msg);  
103.     sem\_post(&p\_msg->s\_empty);  
104.   
105.     **return** TRUE;  
106. \}  
107.   
108.   
109. **void**\* set\_func(**void**\* args)  
110. \{  
111.     **int** index = 100;  
112.       
113.     **while**(1)  
114.     \{  
115.         put\_msg(p\_msg, index);  
116.         printf("set %d\\n", index);  
117.         index ++; sleep(1);  
118.     \}  
119.   
120.     **return** NULL;  
121. \}  
122.   
123.   
124. **void**\* get\_func(**void**\* args)  
125. \{  
126.     **int** data;  
127.   
128.     **while**(1)  
129.     \{  
130.         get\_msg(p\_msg, &data);  
131.         printf("get %d\\n", data);  
132.         sleep(1);  
133.     \}  
134.   
135.     **return** NULL;      
136. \}  
137.   
138.   
139. **int** main(**int** argc, **char**\* argv\[\])  
140. \{  
141.     pthread\_t pid1, pid2;     
142.     **int** index;    
143.   
144.     p\_msg = alloc\_msg(10);  
145.     **if**(NULL == p\_msg)  
146.     \{  
147.         **goto** end;  
148.     \}  
149.   
150.     **if**(pthread\_create(&pid1, NULL, set\_func, NULL))  
151.     \{  
152.         **goto** end;  
153.     \}  
154.   
155.     **if**(pthread\_create(&pid2, NULL, get\_func, NULL))  
156.     \{  
157.         **goto** end;  
158.     \}  
159.   
160.     **while**(1)  
161.     \{  
162.         sleep(0);  
163.     \}  
164.   
165. end:  
166.     **return** 1;  
167. \}

[1350289195_2087.jpg]: https://img-my.csdn.net/uploads/201210/15/1350289195_2087.jpg
[view plain]: http://blog.csdn.net/feixiaoxing/article/details/7884277#