This class implements semaphores , a classic thread synchronization primitive that can be used to implement mutual exclusion and wait/notify-style thread synchronization. A Semaphore maintains some fixed number (specified when the Semaphore( ) constructor is called) of permits . The acquire( ) method blocks until a permit is available, then decrements the number of available permits and returns. The release( ) method does the reverse: it increments the number of permits, possibly unblocking a thread waiting in acquire( ) . If you pass true as the second argument to the Semaphore( ) constructor, the semaphore treats waiting threads fairly by placing them on a FIFO queue in the order they called acquire( ) and granting permits to the threads in this order. This prevents thread starvation . Figure 16-92. java.util.concurrent.Semaphorepublic class Semaphore implements Serializable { // Public Constructors public Semaphore (int permits ); public Semaphore (int permits , boolean fair ); // Public Instance Methods public void acquire ( ) throws InterruptedException; public void acquire (int permits ) throws InterruptedException; public void acquireUninterruptibly ( ); public void acquireUninterruptibly (int permits ); public int availablePermits ( ); public int drainPermits ( ); public final int getQueueLength ( ); public final boolean hasQueuedThreads ( ); public boolean isFair ( ); public void release ( ); public void release (int permits ); public boolean tryAcquire ( ); public boolean tryAcquire (int permits ); public boolean tryAcquire (long timeout , TimeUnit unit ) throws InterruptedException; public boolean tryAcquire (int permits , long timeout , TimeUnit unit ) throws InterruptedException; // Public Methods Overriding Object public String toString ( ); // Protected Instance Methods protected java.util.Collection<Thread> getQueuedThreads ( ); protected void reducePermits (int reduction ); } |