blob: 4b945258b8d9c7dd23c5f0ce26b9c746089b4f4a (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<html> <head>
<title>Locks</title>
</head>
<body>
Interfaces and classes providing a framework for locking and waiting
for conditions that is distinct from built-in synchronization and
monitors. The framework permits much greater flexibility in the use of
locks and conditions, at the expense of more awkward syntax.
<p> The {@link java.util.concurrent.locks.Lock} interface supports
locking disciplines that differ in semantics (reentrant, fair, etc),
and that can be used in non-block-structured contexts including
hand-over-hand and lock reordering algorithms. The main implementation
is {@link java.util.concurrent.locks.ReentrantLock}.
<p> The {@link java.util.concurrent.locks.ReadWriteLock} interface
similarly defines locks that may be shared among readers but are
exclusive to writers. Only a single implementation, {@link
java.util.concurrent.locks.ReentrantReadWriteLock}, is provided, since
it covers most standard usage contexts. But programmers may create
their own implementations to cover nonstandard requirements.
<p> The {@link java.util.concurrent.locks.Condition} interface
describes condition variables that may be associated with Locks.
These are similar in usage to the implicit monitors accessed using
<tt>Object.wait</tt>, but offer extended capabilities. In particular,
multiple <tt>Condition</tt> objects may be associated with a single
<tt>Lock</tt>. To avoid compatibility issues, the names of
<tt>Condition</tt> methods are different than the corresponding
<tt>Object</tt> versions.
<p> The {@link java.util.concurrent.locks.AbstractQueuedSynchronizer}
class serves as a useful superclass for defining locks and other
synchronizers that rely on queuing blocked threads. The {@link
java.util.concurrent.locks.AbstractQueuedLongSynchronizer} class
provides the same functionality but extends support to 64 bits of
synchronization state. Both extend class {@link
java.util.concurrent.locks.AbstractOwnableSynchronizer}, a simple
class that helps record the thread currently holding exclusive
synchronization. The {@link java.util.concurrent.locks.LockSupport}
class provides lower-level blocking and unblocking support that is
useful for those developers implementing their own customized lock
classes.
@since 1.5
</body> </html>
|
