Documentation API of the 'org.clapper.util.misc.Semaphore' Java class

Interface Semaphore

  • All Known Implementing Classes:

    J2SE 5.0 now provides a java.util.concurrent.Semaphore class

    public interface Semaphore

    NOTE: This interface, and its subclasses, are deprecated. With J2SE 5.0 (a.k.a., Java 1.5), the JDK provides its own semaphore class, java.util.concurrent.Semaphore.

    The Semaphore interface specifies a classic counting semaphore. This interface can be implemented in a variety of ways, including (but not limited to) the following:

    • using the Java object-locking primitives (see, for instance, the ObjectLockSemaphore)
    • using the Java Native Interface (JNI) to access an underlying operating system semaphore primitive (e.g., the System V semaphore service on a Unix system)

    The following description of a semaphore is paraphrased from An Introduction to Operating Systems, by Harvey M. Deitel (Addison-Wesley, 1983, p. 88):

    "[Edsgar] Dijkstra developed the concept of semaphores ... as an aid to synchronizing processes. A semaphore is a variable that can be operated upon only by the synchronizing primitives, P and V (letters corresponding to words in Dijkstra's native language, Dutch) defined as follows:

    • P(S): wait for S to become greater than zero and then subtract 1 from S and proceed
    • V(S): add 1 to S and then proceed

    "P allows a process to block itself voluntarily while it waits for an event to occur. V allows another process to wake up a blocked process. Each of these operations must be performed indivisibly; that is, the are not interruptible. The V-operation cannot block the process that performs it."

    Within this Semaphore class, the P operation corresponds to the acquire() method, and the V operation corresponds to the release() method.

    In other programming languages, one common use for a semaphore is to lock a critical section. For example, a semaphore is often used to synchronize access to a data structure that's shared between one or more processes or threads. Since the Java language has built in support for interthread synchronization (via the synchronized keyword), semaphores are not needed for that purpose in Java.

    However, semaphores are still useful in some scenarios. Consider the case where you have a fixed-size pool of shared buffers to be shared between all running threads. For whatever reason, you cannot allocate more buffers; you're stuck with the fixed number. How do you control access to the buffers when there are more threads than there are buffers? A semaphore makes this job much easier:

    • Create a semaphore that's associated with the buffer pool.
    • Initialize the semaphore's counter to the number of buffers in the pool.
    • Whenever a thread wants a buffer, it must first acquire the semaphore.
    • Whenever a thread releases a buffer back to the pool, it must also release the semaphore.

    If a thread attempts to allocate a buffer from the pool, and there is at least one buffer in the pool, the thread's attempt to acquire the semaphore will succeed, and it can safely get the buffer. However, if there are no buffers in the pool, the buffer pool semaphore will be 0, and the thread will have to wait until (a) a buffer is returned to the pool, which will "kick" the semaphore and awaken the thread, or (b) the semaphore's acquire() method times out.

Warning: You cannot see the full API documentation of this class since the access to the DatMelt documentation for third-party Java classes is denied. Guests can only view jhplot Java API. To view the complete description of this class and its methods, please request the full DataMelt membership.

If you are already a full member, please login to the DataMelt member area before visiting this documentation.