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.Semaphore
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 );
}