A preliminary tutorial on multi-thread synchronization-design and use of Simaphore

In the previous article "Preliminary tutorial on multithreading synchronization -- design and use of Metux", we discussed the design and implementation of Mutux in Doug Lea's concurrent package, this article discusses the design and use of Simaphore, which is also common in multithreaded programming. Simaphore also inherits from the Sync interface. Compared with Mutex, Simaphore adds support for Synchronous counting. A Simaphore represents multiple licenses. You can obtain multiple licenses at a time or release multiple licenses at a time. If you reduce the number of Simaphore licenses to 1, it can be used as a Mutex. The following code demonstrates the basic usage of Simaphore:

1.  ClassPool {
2. Static FinalMAX_AVAILABLE = 100;// 100 licenses
3. Private FinalSemaphore available =NewSemaphore (MAX_AVAILABLE );
5. Public ObjectGetItem ()Throws InterruptedException{// No synch
6. Available. acquire ();
7. ReturnGetNextAvailableItem ();
8. }
9.  
10. Public VoidPutItem (ObjectX ){// No synch
11. If(MarkAsUnused (x ))
12. Available. release ();
13. }
14.  
15. // Not a particle ly efficient data structure; just for demo
16.  
17. Protected Object[] Items =... whatever kinds of items being managed
18. Protected Boolean[] Used =New Boolean[MAX_AVAILABLE];
19.  
20. Protected Synchronized ObjectGetNextAvailableItem (){
21. For(IntI = 0; I <MAX_AVAILABLE; ++ I ){
22. If(! Used [I]) {
23. Used [I] =True;
24. ReturnItems [I];
25. }
26. }
27. Return Null;// Not reached
28. }
29.  
30. Protected Synchronized BooleanMarkAsUnused (ObjectItem ){
31. For(IntI = 0; I <MAX_AVAILABLE; ++ I ){
32. If(Item = items [I]) {
33. If(Used [I]) {
34. Used [I] =False;
35. Return True;
36. }
37. Else
38. Return False;
39. }
40. }
41. Return False;
42. }
43.  
44. }

It can be seen that Simaphore is an enhancement of Mutex, and Simaphore is also compared with Mutex, the following method is added:

1. public Semaphore (long initialPermits)
Constructor to specify the number of licenses.
2. public synchronized long permits ()
The number of returned licenses.
3. public synchronized void release (long n)
Release n licenses at a time.

Correspondingly, in the implementation of Simaphore, a field is also added, the number of storage licenses:
Protected long permits _;

The acquire and release methods have also changed accordingly:

1. /** Wait until a permit is available, and take one **/
2. Public VoidAcquire ()Throws InterruptedException{
3. If(Thread. Interrupted ())Throw New InterruptedException();
4. Synchronized(This){
5. Try{
6. While(Permits _ <= 0) wait ();
7. -- Permits _;
8. }
9. & Nb