interprocess communication Quad (semaphore)

1. What is semaphore?

To prevent a series of problems that arise from the simultaneous access of multiple programs to a shared resource, we need a method that can be authorized by generating and using tokens, and at any one time there can be only one critical region that executes thread access code. A critical region is a code that performs data updates that needs to be executed exclusively.　　And semaphores can provide such an access mechanism, so that a critical section at the same time only one thread is accessing it, that is, the semaphore is used to attune process access to shared resources. A semaphore is a special variable whose access is atomic, and only allows it to wait (that is, p (signal variable)) and send (that is, V (signal variable)) information operation. The simplest semaphore is a variable of only 0 and 1, which is also the most common form of semaphore, called the binary semaphore. A semaphore that can take multiple positive integers is called a generic semaphore. The main discussion here is the binary signal volume. 2. How the semaphore works because the semaphore can only perform two operation wait and send signals, namely P (SV) and V (SV), their behavior is this: P (SV): If the value of SV is greater than 0, give it minus 1, if its value is zero, suspend the execution of the process V (SV) : If another process is suspended because it waits for the SV, let it run again, and if no process is suspended because it waits for the SV, add 1 to it. For example, two processes share the semaphore SV, and once one of the processes performs a P (SV) operation, it will get the semaphore and can enter the critical section, reducing the SV by 1. The second process is prevented from entering the critical section because when it attempts to execute P (SV), the SV is 0, it is suspended to wait for the first process to leave the critical area and performs a V (SV) Release semaphore, and the second process can resume execution. 3. Linux semaphore mechanism Linux provides a set of well-designed semaphore interfaces to operate on signals that are not just for binary semaphores, but are described below, but note that these functions are used to manipulate the set of semaphore values. They are declared in the header file sys/sem.h. 3.1 Semget function Its function is to create a new semaphore or to obtain an existing semaphore, the prototype is:int Semget (key_t key, int num_sems, int sem_flags); The first parameter, key, is an integer value (unique not 0), and an unrelated process can access a semaphore, which represents a resource that the program may want to use, and the program accesses all semaphores indirectly, by calling the Semget function and providing a key. The system generates a corresponding signal identifier (the return value of the Semget function), and only the Semget function uses the semaphore key directly, and all other semaphore functions use the semaphore identifier returned by the Semget function. If multiple programs use the same key value, key will be responsible for coordinating the work. The second parameter, Num_sems, specifies the number of semaphores required, and its value is almost always 1. The third parameter, Sem_flags, is a set of flags that, when you want to create a new semaphore when the semaphore does not exist, you can do a bitwise OR operation with the value ipc_creat. When the IPC_CREAT flag is set, the given key is not an error if it is a key that already has a semaphore. and Ipc_creat | IPC_EXCL can create a new, unique semaphore that returns an error if the semaphore already exists. The Semget function successfully returns a corresponding signal identifier (not 0), and the failure returns-1. 3.2 Semop function It is to change the value of the semaphore, the prototype is:int semop (int sem_id, struct sembuf *sem_opa, size_t num_sem_ops); SEM_ID is the semaphore identifier returned by Semget, and the SEMBUF structure is defined as follows:struct sembuf{

Short sem_num; //Unless a set of semaphores is used, it is 0

　　　　　　　　Short sem_op; //Semaphore the data that needs to be changed in a single operation, usually two numbers, one is-1, that is, p (wait) operation,  one is +1, which is the V (Send signal) operation.

　　　　　　　　Short SEM_FLG; //usually Sem_undo, which enables the operating system to trace signals, and when the process terminates without releasing the semaphore, the operating system releases the semaphore

};

3.3 Semctl function This function is used to directly control the semaphore information, its prototype is:int semctl (int sem_id, int sem_num, int command, ...); If there is a fourth argument, it is usually a union semum structure, defined as follows:Union semun{

int Val;

　　　　　　　　struct Semid_ds *buf;

unsigned short *arry;

};

The first two arguments are the same as in the previous one, and the command is usually one of the following two values: used to initialize the semaphore to a known value, Setval. P This value is set by the Val member in the Union Semun, which is set before the semaphore is used for the first time. Ipc_rmid: Used to delete a semaphore identifier that has not been used for further use. 4. Process using semaphore communication below is an example of how the semaphore is used to communicate between processes, this example is two identical programs simultaneously output data to the screen, we can see how to use semaphores to coordinate the work of two processes so that only one process at a time can output data to the screen. Note that if the program is first called (in order to differentiate, the first time the program is called with a character to output to the screen as a parameter), you need to call the Set_semvalue function to initialize the signal and set the message character to the first character of the argument passed to the program, The first process that starts is also responsible for the deletion of semaphores. If you do not delete the semaphore, it will continue to exist in the system, even if the program has exited, it may cause problems the next time you run this program, and the semaphore is a limited resource. Call Semget in the main function to create a semaphore that returns a semaphore identifier stored in the global variable sem_id, which is then used by subsequent functions to access the semaphore. The source file is semaphore.c and the code is as follows:

2. #include <unistd.h>
4. #include <sys/types.h>
6. #include <sys/stat.h>
8. #include <fcntl.h>
10. #include <stdlib.h>
12. #include <stdio.h>
14. #include <string.h>
16. #include <sys/sem.h>
20. Union Semun
22. {
24. int val;
26. struct Semid_ds *buf;
28. unsigned short *arry;
30. };
34. static int sem_id = 0;
38. static int set_semvalue ();
40. static void Del_semvalue ();
42. static int semaphore_p ();
44. static int semaphore_v ();
48. int main (int argc, char *argv[])
50. {
52. char message = ' X ';
54. int i = 0;
58. //Create semaphores
60. sem_id = Semget ((key_t) 1234, 1, 0666 | Ipc_creat);
64. if (argc > 1)
66. {
68. //program is called for the first time, initializing the semaphore
70. if (!set_semvalue ())
72. {
74. fprintf (stderr, "Failed to initialize semaphore\n");
76. Exit (Exit_failure);
78. }
80. //Set the information to be output to the screen, i.e. the first character of its argument
82. message = Argv[1][0];
84. Sleep (2);
86. }
88. For (i = 0; i <; ++i)
90. {
92. //Enter the critical section
94. if (!semaphore_p ())
96. Exit (Exit_failure);
98. //Output data to the screen
100. printf ("%c", message);
102. //clean buffer, then hibernate random time
104. Fflush (stdout);
106. Sleep (rand ()% 3);
108. //exit the critical section before outputting data to the screen again
110. printf ("%c", message);
112. Fflush (stdout);
114. //Leave critical section, resume cycle after a random time of sleep
116. if (!semaphore_v ())
118. Exit (Exit_failure);
120. Sleep (rand ()% 2);
122. }
126. Sleep (10);
128. printf ("\n%d-finished\n", Getpid ());
132. if (argc > 1)
134. {
136. //If the program is called for the first time, remove the semaphore before exiting
138. Sleep (3);
140. Del_semvalue ();
142. }
144. Exit (exit_success);
146. }
150. static int Set_semvalue ()
152. {
154. //Used to initialize semaphores, this must be done before using semaphores
156. Union Semun Sem_union;
160. Sem_union.val = 1;
162. if (semctl (sem_id, 0, setval, sem_union) = =-1)
164. return 0;
166. return 1;
168. }
172. static void Del_semvalue ()
174. {
176. //delete semaphore
178. Union Semun Sem_union;
182. if (semctl (sem_id, 0, ipc_rmid, sem_union) = =-1)
184. fprintf (stderr, "Failed to delete semaphore\n");
186. }
190. static int semaphore_p ()
192. {
194. //To reduce the semaphore by 1 operation, that is, wait P (SV)
196. struct SEMBUF sem_b;
198. Sem_b.sem_num = 0;
200. Sem_b.sem_op =-1; //p ()
202. SEM_B.SEM_FLG = Sem_undo;
204. if (Semop (sem_id, &sem_b, 1) = =-1)
206. {
208. fprintf (stderr, "semaphore_p failed\n");
210. return 0;
212. }
214. return 1;
216. }
220. static int Semaphore_v ()
222. {
224. //This is a release operation that makes the signal available, i.e. Send signal V (SV)
226. struct SEMBUF sem_b;
228. Sem_b.sem_num = 0;
230. Sem_b.sem_op = 1; //v ()
232. SEM_B.SEM_FLG = Sem_undo;
234. if (Semop (sem_id, &sem_b, 1) = =-1)
236. {
238. fprintf (stderr, "Semaphore_v failed\n");
240. return 0;
242. }
244. return 1;
246. }

The results of the operation are as follows:

[[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]$

Note: The critical section of this program is the code in the middle of the semaphore_p and SEMAPHORE_V functions for the main function for loop. Example analysis: Run two instances of a program at the same time, note that the first run, with a character as a parameter, such as the character ' O ' in this example, is used to differentiate whether it is the first call, and this character is output to the screen. Because each program prints a character before it enters the critical section and before it leaves the critical section, each character should appear in pairs, as you see in the output. In the main function loop we can see that every time the process wants to access stdout (standard output), that is, to output characters, each time to check whether the semaphore is available (that is, stdout is not being used by another process). Therefore, when a process a calls the function Semaphore_p enters the critical section, after the output character, call sleep, another process B may want to access stdout, but the semaphore p request operation fails, can only suspend its own execution, when process a calls the function semaphore_ V leaves the critical section, and process B is immediately resumed execution.  Then process A and process B have been circulating 10 times. 5. The sum of the semaphore is a special variable whose access is atomic and allows only waiting (that is, p (signal variable)) and sending (i.e. V (signal variable)) information operations.　　We usually use signals to solve the problem of multiple process access to the same resource, so that at any one time there can be only one critical region to execute thread access code, or it can be said to coordinate access to the same resource between processes, that is, for the synchronization process. The intent of the semaphore is inter-process synchronization, and the intent of the mutex and condition variables is synchronization between threads. But semaphores can also be used between threads, and mutex and condition variables can also be used for inter-process text: http://blog.csdn.net/ljianhui/article/details/10243617

interprocess communication Quad (semaphore)