- Barrier
-
A barrier is a
rendezvous point
for multiple threads: all threads must arrive at the barrier before
any of them are permitted to proceed past the barrier. J2SE 5.0
supplies a barrier class, and a barrier class for previous versions
of Java can be found in the Appendix A.
- Condition variable
-
A condition
variable is not actually a lock; it
is a variable associated with a lock. Condition variables are often
used in the context of data synchronization. Condition variables
generally have an API that achieves the same functionality as
Java's wait-and-notify mechanism; in that mechanism,
the condition variable is actually the object lock it is protecting.
J2SE 5.0 also supplies explicit condition variables, and a condition
variable implementation for previous versions of Java can be found in
the Appendix A. Both kinds of condition
variables are discussed in Chapter 4.
- Critical section
-
A
critical section is a synchronized
method or block. Critical sections do not nest like synchronized
methods or blocks.
- Event variable
-
Event variable
is
another term for a condition variable.
- Lock
-
This term refers to
the
access granted to a particular thread that has entered a synchronized
method or block. We say that a thread that has entered such a method
or block has acquired the lock. As we discussed in Chapter 3, a lock is associated with either a
particular instance of an object or a particular class.
- Monitor
-
A generic synchronization term used inconsistently between threading
systems. In some systems, a monitor is simply a lock; in others, a
monitor is similar to the wait-and-notify mechanism.
- Mutex
-
Another term for a lock.
Mutexes do not nest
like synchronization methods or blocks and generally can be used
across processes at the operating system level.
- Reader/writer locks
-
A lock that can be
acquired
by multiple threads simultaneously as long as the threads agree to
only read from the shared data or that can be acquired by a single
thread that wants to write to the shared data. J2SE 5.0 supplies a
reader-writer lock class, and a similar class for previous versions
of Java can be found in the Appendix A.
- Semaphores
-
Semaphores are used inconsistently in computer systems. Many
developers use
semaphores
to lock objects in the same way Java locks are used; this usage makes
them equivalent to mutexes. A more sophisticated use of semaphores is
to take advantage of a counter associated with them to nest
acquisitions to the critical sections of code; Java locks are exactly
equivalent to semaphores in this usage. Semaphores are also used to
gain access to resources other than code.
Semaphore
classes that implement most of these features are available in J2SE
5.0.
