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.

public 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);
}