C language wait () semaphores part signal () semaphores part code

Http://blog.csdn.net/raykid13/archive/2008/10/16/3087858.aspx

The semaphore structure is expressed in C as follows:

1. TypedefStruct{
2. IntValue;// Records the semaphore Value
3. StructProcess * List;// Store the process waiting for this semaphore
4. } Semaphore;

Wait () semaphoresCodeAs follows:

1. Wait (semaphore * s ){
2. S-> value --;
3. If(S-> value <0 ){
4. AddThisProcess to s-> list;
5. Block ();
6. }
7. }

Part of the signal () semaphore code is as follows:

1. Signal (semaphore * s ){
2. S-> value ++;
3. If(S-> value <= 0 ){
4. Remove a process P from S-> list;
5. Wakeup (P );
6. }
7. }

1. the bounded-buffer problem:

Full is initialized to 0, empty is initialized to N, and mutex is 1

2. Do{
4. Wait (full );
6. Wait (mutex );
8. ...
10. // Remove an item from buffer to nextc
12. ...
14. Signal (mutex );
16. Signal (empty );
18. ...
20. // Consume the item in nextc
22. ...
24. }While(True );

II. The readers-writers problem:

WRT Initialization is 1, readcount Initialization is 0, mutex is 1

Writer operation:

 

1. Do{
2. Wait (WRT );
3. ...
4. // Writing is saved med
5. ...
6. Signal (WRT );
7. }While(True );

Reader operation:

 

2. Do{
4. Wait (mutex );// Ensure that operations with signal (mutex) are not interrupted by other readers
6. Readcount ++;
8. If(Readcount = 1)
10. Wait (WRT );
12. Signal (mutex );
14. ...
16. // Reading is already med
18. ...
20. Wait (mutex );
22. Readcount --;
24. If(Readcount = 0)
26. Signal (WRT );
28. Signal (mutex );
30. }While(True );

III. The dining-philosophers problem:

All chopstick [5] is initialized to 1.

2. Do{
4. Wait (chopstick [I]);
6. Wait (chopstick [(I + 1) % 5]);
8. ...
10. // Eating
12. ...
14. Signal (chopstick [I]);
16. Signal (chopstick [(I + 1) % 5]);
18. ...
20. // Thinking
22. ...
24. }While(True );

But the biggest problem with this solution is its deadlock. So I think we should add a semaphore mutex and initialize it to 1:

2. Do{
4. Wait (mutex );
6. Wait (chopstick [I]);
8. Wait (chopstick [(I + 1) % 5]);
10. Signal (mutex );
12. ...
14. // Eating
16. ...
18. Wait (mutex );
20. Signal (chopstick [I]);
22. Signal (chopstick [(I + 1) % 5]);
24. Signal (mutex );
26. ...
28. // Thinking
30. ...
32. }While(True );

In this way, it is ensured that a philosopher cannot pick up any chopsticks during the time when he picks up two chopsticks, thus undermining the hold and wait features of the four features required for deadlock, this avoids deadlocks.

 

Finally, the deadlock has four features:

1. Mutual exclusion;

2. Hold and wait;

3. No preemption;

4. Circular wait;

When all four conditions are met, a deadlock may occur.