本文详细介绍了Java的ReentrantReadWriteLock共享锁的使用方式、特性及其实现原理，包括读写锁的获取、释放、公平性和非公平性策略，以及在并发编程中的应用案例。
概要
Java的JUC(java.util.concurrent)包中的锁包括"独占锁"和"共享锁"。在“Java多线程系列--“JUC锁”02之 互斥锁ReentrantLock ”中，对Java的独占锁进行了说明。本章对Java的“共享锁”进行介绍，JUC中的共享锁有CountDownLatch, CyclicBarrier, Semaphore, ReentrantReadWriteLock等；本章会以ReentrantReadWriteLock为蓝本对共享锁进行说明。内容包括：
ReadWriteLock 和 ReentrantReadWriteLock介绍
ReadWriteLock 和 ReentrantReadWriteLock函数列表
ReentrantReadWriteLock数据结构
参考代码(基于JDK1.7.0_40)
获取共享锁
释放共享锁
公平共享锁和非公平共享锁
ReentrantReadWriteLock示例
转载请注明出处：http://www.cnblogs.com/skywang12345/p/3505809.html
ReadWriteLock 和 ReentrantReadWriteLock介绍
ReadWriteLock，顾名思义，是读写锁。它维护了一对相关的锁 — — “读取锁”和“写入锁”，一个用于读取操作，另一个用于写入操作。
“读取锁”用于只读操作，它是“共享锁”，能同时被多个线程获取。
“写入锁”用于写入操作，它是“独占锁”，写入锁只能被一个线程锁获取。
注意：不能同时存在读取锁和写入锁！
ReadWriteLock是一个接口。ReentrantReadWriteLock是它的实现类，ReentrantReadWriteLock包括子类ReadLock和WriteLock。
ReadWriteLock 和 ReentrantReadWriteLock函数列表
ReadWriteLock函数列表
// 返回用于读取操作的锁。 Lock readLock() // 返回用于写入操作的锁。 Lock writeLock()
// 创建一个新的 ReentrantReadWriteLock，默认是采用“非公平策略”。 ReentrantReadWriteLock() // 创建一个新的 ReentrantReadWriteLock，fair是“公平策略”。fair为true，意味着公平策略；否则，意味着非公平策略。 ReentrantReadWriteLock(boolean fair) // 返回当前拥有写入锁的线程，如果没有这样的线程，则返回 null。 protected Thread getOwner() // 返回一个 collection，它包含可能正在等待获取读取锁的线程。 protected Collection<Thread> getQueuedReaderThreads() // 返回一个 collection，它包含可能正在等待获取读取或写入锁的线程。 protected Collection<Thread> getQueuedThreads() // 返回一个 collection，它包含可能正在等待获取写入锁的线程。 protected Collection<Thread> getQueuedWriterThreads() // 返回等待获取读取或写入锁的线程估计数目。 int getQueueLength() // 查询当前线程在此锁上保持的重入读取锁数量。 int getReadHoldCount() // 查询为此锁保持的读取锁数量。 int getReadLockCount() // 返回一个 collection，它包含可能正在等待与写入锁相关的给定条件的那些线程。 protected Collection<Thread> getWaitingThreads(Condition condition) // 返回正等待与写入锁相关的给定条件的线程估计数目。 int getWaitQueueLength(Condition condition) // 查询当前线程在此锁上保持的重入写入锁数量。 int getWriteHoldCount() // 查询是否给定线程正在等待获取读取或写入锁。 boolean hasQueuedThread(Thread thread) // 查询是否所有的线程正在等待获取读取或写入锁。 boolean hasQueuedThreads() // 查询是否有些线程正在等待与写入锁有关的给定条件。 boolean hasWaiters(Condition condition) // 如果此锁将公平性设置为 ture，则返回 true。 boolean isFair() // 查询是否某个线程保持了写入锁。 boolean isWriteLocked() // 查询当前线程是否保持了写入锁。 boolean isWriteLockedByCurrentThread() // 返回用于读取操作的锁。 ReentrantReadWriteLock.ReadLock readLock() // 返回用于写入操作的锁。 ReentrantReadWriteLock.WriteLock writeLock()
ReentrantReadWriteLock数据结构
ReentrantReadWriteLock的UML类图如下：
从中可以看出：
(01) ReentrantReadWriteLock实现了ReadWriteLock接口。ReadWriteLock是一个读写锁的接口，提供了"获取读锁的readLock()函数" 和 "获取写锁的writeLock()函数"。
(02) ReentrantReadWriteLock中包含：sync对象，读锁readerLock和写锁writerLock。读锁ReadLock和写锁WriteLock都实现了Lock接口。读锁ReadLock和写锁WriteLock中也都分别包含了"Sync对象"，它们的Sync对象和ReentrantReadWriteLock的Sync对象 是一样的，就是通过sync，读锁和写锁实现了对同一个对象的访问。
(03) 和"ReentrantLock"一样，sync是Sync类型；而且，Sync也是一个继承于AQS的抽象类。Sync也包括"公平锁"FairSync和"非公平锁"NonfairSync。sync对象是"FairSync"和"NonfairSync"中的一个，默认是"NonfairSync"。
参考代码(基于JDK1.7.0_40)
ReentrantReadWriteLock的完整源码
1 /*
2 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
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 * Written by Doug Lea with assistance from members of JCP JSR-166
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36 package java.util.concurrent.locks;
37 import java.util.concurrent.*;
38 import java.util.concurrent.atomic.*;
39 import java.util.*;
40
41 /**
42 * An implementation of {@link ReadWriteLock} supporting similar
43 * semantics to {@link ReentrantLock}.
44 * <p>This class has the following properties:
45 *
46 * <ul>
47 * <li><b>Acquisition order</b>
48 *
49 * <p> This class does not impose a reader or writer preference
50 * ordering for lock access. However, it does support an optional
51 * <em>fairness</em> policy.
52 *
53 * <dl>
54 * <dt><b><i>Non-fair mode (default)</i></b>
55 * <dd>When constructed as non-fair (the default), the order of entry
56 * to the read and write lock is unspecified, subject to reentrancy
57 * constraints. A nonfair lock that is continuously contended may
58 * indefinitely postpone one or more reader or writer threads, but
59 * will normally have higher throughput than a fair lock.
60 * <p>
61 *
62 * <dt><b><i>Fair mode</i></b>
63 * <dd> When constructed as fair, threads contend for entry using an
64 * approximately arrival-order policy. When the currently held lock
65 * is released either the longest-waiting single writer thread will
66 * be assigned the write lock, or if there is a group of reader threads
67 * waiting longer than all waiting writer threads, that group will be
68 * assigned the read lock.
69 *
70 * <p>A thread that tries to acquire a fair read lock (non-reentrantly)
71 * will block if either the write lock is held, or there is a waiting
72 * writer thread. The thread will not acquire the read lock until
73 * after the oldest currently waiting writer thread has acquired and
74 * released the write lock. Of course, if a waiting writer abandons
75 * its wait, leaving one or more reader threads as the longest waiters
76 * in the queue with the write lock free, then those readers will be
77 * assigned the read lock.
78 *
79 * <p>A thread that tries to acquire a fair write lock (non-reentrantly)
80 * will block unless both the read lock and write lock are free (which
81 * implies there are no waiting threads). (Note that the non-blocking
82 * {@link ReadLock#tryLock()} and {@link WriteLock#tryLock()} methods
83 * do not honor this fair setting and will acquire the lock if it is
84 * possible, regardless of waiting threads.)
85 * <p>
86 * </dl>
87 *
88 * <li><b>Reentrancy</b>
89 *
90 * <p>This lock allows both readers and writers to reacquire read or
91 * write locks in the style of a {@link ReentrantLock}. Non-reentrant
92 * readers are not allowed until all write locks held by the writing
93 * thread have been released.
94 *
95 * <p>Additionally, a writer can acquire the read lock, but not
96 * vice-versa. Among other applications, reentrancy can be useful
97 * when write locks are held during calls or callbacks to methods that
98 * perform reads under read locks. If a reader tries to acquire the
99 * write lock it will never succeed.
100 *
101 * <li><b>Lock downgrading</b>
102 * <p>Reentrancy also allows downgrading from the write lock to a read lock,
103 * by acquiring the write lock, then the read lock and then releasing the
104 * write lock. However, upgrading from a read lock to the write lock is
105 * <b>not</b> possible.
106 *
107 * <li><b>Interruption of lock acquisition</b>
108 * <p>The read lock and write lock both support interruption during lock
109 * acquisition.
110 *
111 * <li><b>{@link Condition} support</b>
112 * <p>The write lock provides a {@link Condition} implementation that
113 * behaves in the same way, with respect to the write lock, as the
114 * {@link Condition} implementation provided by
115 * {@link ReentrantLock#newCondition} does for {@link ReentrantLock}.
116 * This {@link Condition} can, of course, only be used with the write lock.
117 *
118 * <p>The read lock does not support a {@link Condition} and
119 * {@code readLock().newCondition()} throws
120 * {@code UnsupportedOperationException}.
121 *
122 * <li><b>Instrumentation</b>
123 * <p>This class supports methods to determine whether locks
124 * are held or contended. These methods are designed for monitoring
125 * system state, not for synchronization control.
126 * </ul>
127 *
128 * <p>Serialization of this class behaves in the same way as built-in
129 * locks: a deserialized lock is in the unlocked state, regardless of
130 * its state when serialized.
131 *
132 * <p><b>Sample usages</b>. Here is a code sketch showing how to perform
133 * lock downgrading after updating a cache (exception handling is
134 * particularly tricky when handling multiple locks in a non-nested
135 * fashion):
136 *
137 * <pre> {@code
138 * class CachedData {
139 * Object data;
140 * volatile boolean cacheValid;
141 * final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
142 *
143 * void processCachedData() {
144 * rwl.readLock().lock();
145 * if (!cacheValid) {
146 * // Must release read lock before acquiring write lock
147 * rwl.readLock().unlock();
148 * rwl.writeLock().lock();
149 * try {
150 * // Recheck state because another thread might have
151 * // acquired write lock and changed state before we did.
152 * if (!cacheValid) {
153 * data = ...
154 * cacheValid = true;
155 * }
156 * // Downgrade by acquiring read lock before releasing write lock
157 * rwl.readLock().lock();
158 * } finally {
159 * rwl.writeLock().unlock(); // Unlock write, still hold read
160 * }
161 * }
162 *
163 * try {
164 * use(data);
165 * } finally {
166 * rwl.readLock().unlock();
167 * }
168 * }
169 * }}</pre>
170 *
171 * ReentrantReadWriteLocks can be used to improve concurrency in some
172 * uses of some kinds of Collections. This is typically worthwhile
173 * only when the collections are expected to be large, accessed by
174 * more reader threads than writer threads, and entail operations with
175 * overhead that outweighs synchronization overhead. For example, here
176 * is a class using a TreeMap that is expected to be large and
177 * concurrently accessed.
178 *
179 * <pre>{@code
180 * class RWDictionary {
181 * private final Map<String, Data> m = new TreeMap<String, Data>();
182 * private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
183 * private final Lock r = rwl.readLock();
184 * private final Lock w = rwl.writeLock();
185 *
186 * public Data get(String key) {
187 * r.lock();
188 * try { return m.get(key); }
189 * finally { r.unlock(); }
190 * }
191 * public String[] allKeys() {
192 * r.lock();
193 * try { return m.keySet().toArray(); }
194 * finally { r.unlock(); }
195 * }
196 * public Data put(String key, Data value) {
197 * w.lock();
198 * try { return m.put(key, value); }
199 * finally { w.unlock(); }
200 * }
201 * public void clear() {
202 * w.lock();
203 * try { m.clear(); }
204 * finally { w.unlock(); }
205 * }
206 * }}</pre>
207 *
208 * <h3>Implementation Notes</h3>
209 *
210 * <p>This lock supports a maximum of 65535 recursive write locks
211 * and 65535 read locks. Attempts to exceed these limits result in
212 * {@link Error} throws from locking methods.
213 *
214 * @since 1.5
215 * @author Doug Lea
216 *
217 */
218 public class ReentrantReadWriteLock
219 implements ReadWriteLock, java.io.Serializable {
220 private static final long serialVersionUID = -6992448646407690164L;
221 /** Inner class providing readlock */
222 private final ReentrantReadWriteLock.ReadLock readerLock;
223 /** Inner class providing writelock */
224 private final ReentrantReadWriteLock.WriteLock writerLock;
225 /** Performs all synchronization mechanics */
226 final Sync sync;
227
228 /**
229 * Creates a new {@code ReentrantReadWriteLock} with
230 * default (nonfair) ordering properties.
231 */
232 public ReentrantReadWriteLock() {
233 this(false);
234 }
235
236 /**
237 * Creates a new {@code ReentrantReadWriteLock} with
238 * the given fairness policy.
239 *
240 * @param fair {@code true} if this lock should use a fair ordering policy
241 */
242 public ReentrantReadWriteLock(boolean fair) {
243 sync = fair ? new FairSync() : new NonfairSync();
244 readerLock = new ReadLock(this);
245 writerLock = new WriteLock(this);
246 }
247
248 public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
249 public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; }
250
251 /**
252 * Synchronization implementation for ReentrantReadWriteLock.
253 * Subclassed into fair and nonfair versions.
254 */
255 abstract static class Sync extends AbstractQueuedSynchronizer {
256 private static final long serialVersionUID = 6317671515068378041L;
257
258 /*
259 * Read vs write count extraction constants and functions.
260 * Lock state is logically divided into two unsigned shorts:
261 * The lower one representing the exclusive (writer) lock hold count,
262 * and the upper the shared (reader) hold count.
263 */
264
265 static final int SHARED_SHIFT = 16;
266 static final int SHARED_UNIT = (1 << SHARED_SHIFT);
267 static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
268 static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
269
270 /** Returns the number of shared holds represented in count */
271 static int sharedCount(int c) { return c >>> SHARED_SHIFT; }
272 /** Returns the number of exclusive holds represented in count */
273 static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
274
275 /**
276 * A counter for per-thread read hold counts.
277 * Maintained as a ThreadLocal; cached in cachedHoldCounter
278 */
279 static final class HoldCounter {
280 int count = 0;
281 // Use id, not reference, to avoid garbage retention
282 final long tid = Thread.currentThread().getId();
283 }
284
285 /**
286 * ThreadLocal subclass. Easiest to explicitly define for sake
287 * of deserialization mechanics.
288 */
289 static final class ThreadLocalHoldCounter
290 extends ThreadLocal<HoldCounter> {
291 public HoldCounter initialValue() {
292 return new HoldCounter();
293 }
294 }
295
296 /**
297 * The number of reentrant read locks held by current thread.
298 * Initialized only in constructor and readObject.
299 * Removed whenever a thread's read hold count drops to 0.
300 */
301 private transient ThreadLocalHoldCounter readHolds;
302
303 /**
304 * The hold count of the last thread to successfully acquire
305 * readLock. This saves ThreadLocal lookup in the common case
306 * where the next thread to release is the last one to
307 * acquire. This is non-volatile since it is just used
308 * as a heuristic, and would be great for threads to cache.
309 *
310 * <p>Can outlive the Thread for which it is caching the read
311 * hold count, but avoids garbage retention by not retaining a
312 * reference to the Thread.
313 *
314 * <p>Accessed via a benign data race; relies on the memory
315 * model's final field and out-of-thin-air guarantees.
316 */
317 private transient HoldCounter cachedHoldCounter;
318
319 /**
320 * firstReader is the first thread to have acquired the read lock.
321 * firstReaderHoldCount is firstReader's hold count.
322 *
323 * <p>More precisely, firstReader is the unique thread that last
324 * changed the shared count from 0 to 1, and has not released the
325 * read lock since then; null if there is no such thread.
326 *
327 * <p>Cannot cause garbage retention unless the thread terminated
328 * without relinquishing its read locks, since tryReleaseShared
329 * sets it to null.
330 *
331 * <p>Accessed via a benign data race; relies on the memory
332 * model's out-of-thin-air guarantees for references.
333 *
334 * <p>This allows tracking of read holds for uncontended read
335 * locks to be very cheap.
336 */
337 private transient Thread firstReader = null;
338 private transient int firstReaderHoldCount;
339
340 Sync() {
341 readHolds = new ThreadLocalHoldCounter();
342 setState(getState()); // ensures visibility of readHolds
343 }
344
345 /*
346 * Acquires and releases use the same code for fair and
347 * nonfair locks, but differ in whether/how they allow barging
348 * when queues are non-empty.
349 */
350
351 /**
352 * Returns true if the current thread, when trying to acquire
353 * the read lock, and otherwise eligible to do so, should block
354 * because of policy for overtaking other waiting threads.
355 */
356 abstract boolean readerShouldBlock();
357
358 /**
359 * Returns true if the current thread, when trying to acquire
360 * the write lock, and otherwise eligible to do so, should block
361 * because of policy for overtaking other waiting threads.
362 */
363 abstract boolean writerShouldBlock();
364
365 /*
366 * Note that tryRelease and tryAcquire can be called by
367 * Conditions. So it is possible that their arguments contain
368 * both read and write holds that are all released during a
369 * condition wait and re-established in tryAcquire.
370 */
371
372 protected final boolean tryRelease(int releases) {
373 if (!isHeldExclusively())
374 throw new IllegalMonitorStateException();
375 int nextc = getState() - releases;
376 boolean free = exclusiveCount(nextc) == 0;
377 if (free)
378 setExclusiveOwnerThread(null);
379 setState(nextc);
380 return free;
381 }
382
383 protected final boolean tryAcquire(int acquires) {
384 /*
385 * Walkthrough:
386 * 1. If read count nonzero or write count nonzero
387 * and owner is a different thread, fail.
388 * 2. If count would saturate, fail. (This can only
389 * happen if count is already nonzero.)
390 * 3. Otherwise, this thread is eligible for lock if
391 * it is either a reentrant acquire or
392 * queue policy allows it. If so, update state
393 * and set owner.
394 */
395 Thread current = Thread.currentThread();
396 int c = getState();
397 int w = exclusiveCount(c);
398 if (c != 0) {
399 // (Note: if c != 0 and w == 0 then shared count != 0)
400 if (w == 0 || current != getExclusiveOwnerThread())
401 return false;
402 if (w + exclusiveCount(acquires) > MAX_COUNT)
403 throw new Error("Maximum lock count exceeded");
404 // Reentrant acquire
405 setState(c + acquires);
406 return true;
407 }
408 if (writerShouldBlock() ||
409 !compareAndSetState(c, c + acquires))
410 return false;
411 setExclusiveOwnerThread(current);
412 return true;
413 }
414
415 protected final boolean tryReleaseShared(int unused) {
416 Thread current = Thread.currentThread();
417 if (firstReader == current) {
418 // assert firstReaderHoldCount > 0;
419 if (firstReaderHoldCount == 1)
420 firstReader = null;
421 else
422 firstReaderHoldCount--;
423 } else {
424 HoldCounter rh = cachedHoldCounter;
425 if (rh == null || rh.tid != current.getId())
426 rh = readHolds.get();
427 int count = rh.count;
428 if (count <= 1) {
429 readHolds.remove();
430 if (count <= 0)
431 throw unmatchedUnlockException();
432 }
433 --rh.count;
434 }
435 for (;;) {
436 int c = getState();
437 int nextc = c - SHARED_UNIT;
438 if (compareAndSetState(c, nextc))
439 // Releasing the read lock has no effect on readers,
440 // but it may allow waiting writers to proceed if
441 // both read and write locks are now free.
442 return nextc == 0;
443 }
444 }
445
446 private IllegalMonitorStateException unmatchedUnlockException() {
447 return new IllegalMonitorStateException(
448 "attempt to unlock read lock, not locked by current thread");
449 }
450
451 protected final int tryAcquireShared(int unused) {
452 /*
453 * Walkthrough:
454 * 1. If write lock held by another thread, fail.
455 * 2. Otherwise, this thread is eligible for
456 * lock wrt state, so ask if it should block
457 * because of queue policy. If not, try
458 * to grant by CASing state and updating count.
459 * Note that step does not check for reentrant
460 * acquires, which is postponed to full version
461 * to avoid having to check hold count in
462 * the more typical non-reentrant case.
463 * 3. If step 2 fails either because thread
464 * apparently not eligible or CAS fails or count
465 * saturated, chain to version with full retry loop.
466 */
467 Thread current = Thread.currentThread();
468 int c = getState();
469 if (exclusiveCount(c) != 0 &&
470 getExclusiveOwnerThread() != current)
471 return -1;
472 int r = sharedCount(c);
473 if (!readerShouldBlock() &&
474 r < MAX_COUNT &&
475 compareAndSetState(c, c + SHARED_UNIT)) {
476 if (r == 0) {
477 firstReader = current;
478 firstReaderHoldCount = 1;
479 } else if (firstReader == current) {
480 firstReaderHoldCount++;
481 } else {
482 HoldCounter rh = cachedHoldCounter;
483 if (rh == null || rh.tid != current.getId())
484 cachedHoldCounter = rh = readHolds.get();
485 else if (rh.count == 0)
486 readHolds.set(rh);
487 rh.count++;
488 }
489 return 1;
490 }
491 return fullTryAcquireShared(current);
492 }
493
494 /**
495 * Full version of acquire for reads, that handles CAS misses
496 * and reentrant reads not dealt with in tryAcquireShared.
497 */
498 final int fullTryAcquireShared(Thread current) {
499 /*
500 * This code is in part redundant with that in
501 * tryAcquireShared but is simpler overall by not
502 * complicating tryAcquireShared with interactions between
503 * retries and lazily reading hold counts.
504 */
505 HoldCounter rh = null;
506 for (;;) {
507 int c = getState();
508 if (exclusiveCount(c) != 0) {
509 if (getExclusiveOwnerThread() != current)
510 return -1;
511 // else we hold the exclusive lock; blocking here
512 // would cause deadlock.
513 } else if (readerShouldBlock()) {
514 // Make sure we're not acquiring read lock reentrantly
515 if (firstReader == current) {
516 // assert firstReaderHoldCount > 0;
517 } else {
518 if (rh == null) {
519 rh = cachedHoldCounter;
520 if (rh == null || rh.tid != current.getId()) {
521 rh = readHolds.get();
522 if (rh.count == 0)
523 readHolds.remove();
524 }
525 }
526 if (rh.count == 0)
527 return -1;
528 }
529 }
530 if (sharedCount(c) == MAX_COUNT)
531 throw new Error("Maximum lock count exceeded");
532 if (compareAndSetState(c, c + SHARED_UNIT)) {
533 if (sharedCount(c) == 0) {
534 firstReader = current;
535 firstReaderHoldCount = 1;
536 } else if (firstReader == current) {
537 firstReaderHoldCount++;
538 } else {
539 if (rh == null)
540 rh = cachedHoldCounter;
541 if (rh == null || rh.tid != current.getId())
542 rh = readHolds.get();
543 else if (rh.count == 0)
544 readHolds.set(rh);
545 rh.count++;
546 cachedHoldCounter = rh; // cache for release
547 }
548 return 1;
549 }
550 }
551 }
552
553 /**
554 * Performs tryLock for write, enabling barging in both modes.
555 * This is identical in effect to tryAcquire except for lack
556 * of calls to writerShouldBlock.
557 */
558 final boolean tryWriteLock() {
559 Thread current = Thread.currentThread();
560 int c = getState();
561 if (c != 0) {
562 int w = exclusiveCount(c);
563 if (w == 0 || current != getExclusiveOwnerThread())
564 return false;
565 if (w == MAX_COUNT)
566 throw new Error("Maximum lock count exceeded");
567 }
568 if (!compareAndSetState(c, c + 1))
569 return false;
570 setExclusiveOwnerThread(current);
571 return true;
572 }
573
574 /**
575 * Performs tryLock for read, enabling barging in both modes.
576 * This is identical in effect to tryAcquireShared except for
577 * lack of calls to readerShouldBlock.
578 */
579 final boolean tryReadLock() {
580 Thread current = Thread.currentThread();
581 for (;;) {
582 int c = getState();
583 if (exclusiveCount(c) != 0 &&
584 getExclusiveOwnerThread() != current)
585 return false;
586 int r = sharedCount(c);
587 if (r == MAX_COUNT)
588 throw new Error("Maximum lock count exceeded");
589 if (compareAndSetState(c, c + SHARED_UNIT)) {
590 if (r == 0) {
591 firstReader = current;
592 firstReaderHoldCount = 1;
593 } else if (firstReader == current) {
594 firstReaderHoldCount++;
595 } else {
596 HoldCounter rh = cachedHoldCounter;
597 if (rh == null || rh.tid != current.getId())
598 cachedHoldCounter = rh = readHolds.get();
599 else if (rh.count == 0)
600 readHolds.set(rh);
601 rh.count++;
602 }
603 return true;
604 }
605 }
606 }
607
608 protected final boolean isHeldExclusively() {
609 // While we must in general read state before owner,
610 // we don't need to do so to check if current thread is owner
611 return getExclusiveOwnerThread() == Thread.currentThread();
612 }
613
614 // Methods relayed to outer class
615
616 final ConditionObject newCondition() {
617 return new ConditionObject();
618 }
619
620 final Thread getOwner() {
621 // Must read state before owner to ensure memory consistency
622 return ((exclusiveCount(getState()) == 0) ?
623 null :
624 getExclusiveOwnerThread());
625 }
626
627 final int getReadLockCount() {
628 return sharedCount(getState());
629 }
630
631 final boolean isWriteLocked() {
632 return exclusiveCount(getState()) != 0;
633 }
634
635 final int getWriteHoldCount() {
636 return isHeldExclusively() ? exclusiveCount(getState()) : 0;
637 }
638
639 final int getReadHoldCount() {
640 if (getReadLockCount() == 0)
641 return 0;
642
643 Thread current = Thread.currentThread();
644 if (firstReader == current)
645 return firstReaderHoldCount;
646
647 HoldCounter rh = cachedHoldCounter;
648 if (rh != null && rh.tid == current.getId())
649 return rh.count;
650
651 int count = readHolds.get().count;
652 if (count == 0) readHolds.remove();
653 return count;
654 }
655
656 /**
657 * Reconstitute this lock instance from a stream
658 * @param s the stream
659 */
660 private void readObject(java.io.ObjectInputStream s)
661 throws java.io.IOException, ClassNotFoundException {
662 s.defaultReadObject();
663 readHolds = new ThreadLocalHoldCounter();
664 setState(0); // reset to unlocked state
665 }
666
667 final int getCount() { return getState(); }
668 }
669
670 /**
671 * Nonfair version of Sync
672 */
673 static final class NonfairSync extends Sync {
674 private static final long serialVersionUID = -8159625535654395037L;
675 final boolean writerShouldBlock() {
676 return false; // writers can always barge
677 }
678 final boolean readerShouldBlock() {
679 /* As a heuristic to avoid indefinite writer starvation,
680 * block if the thread that momentarily appears to be head
681 * of queue, if one exists, is a waiting writer. This is
682 * only a probabilistic effect since a new reader will not
683 * block if there is a waiting writer behind other enabled
684 * readers that have not yet drained from the queue.
685 */
686 return apparentlyFirstQueuedIsExclusive();
687 }
688 }
689
690 /**
691 * Fair version of Sync
692 */
693 static final class FairSync extends Sync {
694 private static final long serialVersionUID = -2274990926593161451L;
695 final boolean writerShouldBlock() {
696 return hasQueuedPredecessors();
697 }
698 final boolean readerShouldBlock() {
699 return hasQueuedPredecessors();
700 }
701 }
702
703 /**
704 * The lock returned by method {@link ReentrantReadWriteLock#readLock}.
705 */
706 public static class ReadLock implements Lock, java.io.Serializable {
707 private static final long serialVersionUID = -5992448646407690164L;
708 private final Sync sync;
709
710 /**
711 * Constructor for use by subclasses
712 *
713 * @param lock the outer lock object
714 * @throws NullPointerException if the lock is null
715 */
716 protected ReadLock(ReentrantReadWriteLock lock) {
717 sync = lock.sync;
718 }
719
720 /**
721 * Acquires the read lock.
722 *
723 * <p>Acquires the read lock if the write lock is not held by
724 * another thread and returns immediately.
725 *
726 * <p>If the write lock is held by another thread then
727 * the current thread becomes disabled for thread scheduling
728 * purposes and lies dormant until the read lock has been acquired.
729 */
730 public void lock() {
731 sync.acquireShared(1);
732 }
733
734 /**
735 * Acquires the read lock unless the current thread is
736 * {@linkplain Thread#interrupt interrupted}.
737 *
738 * <p>Acquires the read lock if the write lock is not held
739 * by another thread and returns immediately.
740 *
741 * <p>If the write lock is held by another thread then the
742 * current thread becomes disabled for thread scheduling
743 * purposes and lies dormant until one of two things happens:
744 *
745 * <ul>
746 *
747 * <li>The read lock is acquired by the current thread; or
748 *
749 * <li>Some other thread {@linkplain Thread#interrupt interrupts}
750 * the current thread.
751 *
752 * </ul>
753 *
754 * <p>If the current thread:
755 *
756 * <ul>
757 *
758 * <li>has its interrupted status set on entry to this method; or
759 *
760 * <li>is {@linkplain Thread#interrupt interrupted} while
761 * acquiring the read lock,
762 *
763 * </ul>
764 *
765 * then {@link InterruptedException} is thrown and the current
766 * thread's interrupted status is cleared.
767 *
768 * <p>In this implementation, as this method is an explicit
769 * interruption point, preference is given to responding to
770 * the interrupt over normal or reentrant acquisition of the
771 * lock.
772 *
773 * @throws InterruptedException if the current thread is interrupted
774 */
775 public void lockInterruptibly() throws InterruptedException {
776 sync.acquireSharedInterruptibly(1);
777 }
778
779 /**
780 * Acquires the read lock only if the write lock is not held by
781 * another thread at the time of invocation.
782 *
783 * <p>Acquires the read lock if the write lock is not held by
784 * another thread and returns immediately with the value
785 * {@code true}. Even when this lock has been set to use a
786 * fair ordering policy, a call to {@code tryLock()}
787 * <em>will</em> immediately acquire the read lock if it is
788 * available, whether or not other threads are currently
789 * waiting for the read lock. This "barging" behavior
790 * can be useful in certain circumstances, even though it
791 * breaks fairness. If you want to honor the fairness setting
792 * for this lock, then use {@link #tryLock(long, TimeUnit)
793 * tryLock(0, TimeUnit.SECONDS) } which is almost equivalent
794 * (it also detects interruption).
795 *
796 * <p>If the write lock is held by another thread then
797 * this method will return immediately with the value
798 * {@code false}.
799 *
800 * @return {@code true} if the read lock was acquired
801 */
802 public boolean tryLock() {
803 return sync.tryReadLock();
804 }
805
806 /**
807 * Acquires the read lock if the write lock is not held by
808 * another thread within the given waiting time and the
809 * current thread has not been {@linkplain Thread#interrupt
810 * interrupted}.
811 *
812 * <p>Acquires the read lock if the write lock is not held by
813 * another thread and returns immediately with the value
814 * {@code true}. If this lock has been set to use a fair
815 * ordering policy then an available lock <em>will not</em> be
816 * acquired if any other threads are waiting for the
817 * lock. This is in contrast to the {@link #tryLock()}
818 * method. If you want a timed {@code tryLock} that does
819 * permit barging on a fair lock then combine the timed and
820 * un-timed forms together:
821 *
822 * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
823 * </pre>
824 *
825 * <p>If the write lock is held by another thread then the
826 * current thread becomes disabled for thread scheduling
827 * purposes and lies dormant until one of three things happens:
828 *
829 * <ul>
830 *
831 * <li>The read lock is acquired by the current thread; or
832 *
833 * <li>Some other thread {@linkplain Thread#interrupt interrupts}
834 * the current thread; or
835 *
836 * <li>The specified waiting time elapses.
837 *
838 * </ul>
839 *
840 * <p>If the read lock is acquired then the value {@code true} is
841 * returned.
842 *
843 * <p>If the current thread:
844 *
845 * <ul>
846 *
847 * <li>has its interrupted status set on entry to this method; or
848 *
849 * <li>is {@linkplain Thread#interrupt interrupted} while
850 * acquiring the read lock,
851 *
852 * </ul> then {@link InterruptedException} is thrown and the
853 * current thread's interrupted status is cleared.
854 *
855 * <p>If the specified waiting time elapses then the value
856 * {@code false} is returned. If the time is less than or
857 * equal to zero, the method will not wait at all.
858 *
859 * <p>In this implementation, as this method is an explicit
860 * interruption point, preference is given to responding to
861 * the interrupt over normal or reentrant acquisition of the
862 * lock, and over reporting the elapse of the waiting time.
863 *
864 * @param timeout the time to wait for the read lock
865 * @param unit the time unit of the timeout argument
866 * @return {@code true} if the read lock was acquired
867 * @throws InterruptedException if the current thread is interrupted
868 * @throws NullPointerException if the time unit is null
869 *
870 */
871 public boolean tryLock(long timeout, TimeUnit unit)
872 throws InterruptedException {
873 return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
874 }
875
876 /**
877 * Attempts to release this lock.
878 *
879 * <p> If the number of readers is now zero then the lock
880 * is made available for write lock attempts.
881 */
882 public void unlock() {
883 sync.releaseShared(1);
884 }
885
886 /**
887 * Throws {@code UnsupportedOperationException} because
888 * {@code ReadLocks} do not support conditions.
889 *
890 * @throws UnsupportedOperationException always
891 */
892 public Condition newCondition() {
893 throw new UnsupportedOperationException();
894 }
895
896 /**
897 * Returns a string identifying this lock, as well as its lock state.
898 * The state, in brackets, includes the String {@code "Read locks ="}
899 * followed by the number of held read locks.
900 *
901 * @return a string identifying this lock, as well as its lock state
902 */
903 public String toString() {
904 int r = sync.getReadLockCount();
905 return super.toString() +
906 "[Read locks = " + r + "]";
907 }
908 }
909
910 /**
911 * The lock returned by method {@link ReentrantReadWriteLock#writeLock}.
912 */
913 public static class WriteLock implements Lock, java.io.Serializable {
914 private static final long serialVersionUID = -4992448646407690164L;
915 private final Sync sync;
916
917 /**
918 * Constructor for use by subclasses
919 *
920 * @param lock the outer lock object
921 * @throws NullPointerException if the lock is null
922 */
923 protected WriteLock(ReentrantReadWriteLock lock) {
924 sync = lock.sync;
925 }
926
927 /**
928 * Acquires the write lock.
929 *
930 * <p>Acquires the write lock if neither the read nor write lock
931 * are held by another thread
932 * and returns immediately, setting the write lock hold count to
933 * one.
934 *
935 * <p>If the current thread already holds the write lock then the
936 * hold count is incremented by one and the method returns
937 * immediately.
938 *
939 * <p>If the lock is held by another thread then the current
940 * thread becomes disabled for thread scheduling purposes and
941 * lies dormant until the write lock has been acquired, at which
942 * time the write lock hold count is set to one.
943 */
944 public void lock() {
945 sync.acquire(1);
946 }
947
948 /**
949 * Acquires the write lock unless the current thread is
950 * {@linkplain Thread#interrupt interrupted}.
951 *
952 * <p>Acquires the write lock if neither the read nor write lock
953 * are held by another thread
954 * and returns immediately, setting the write lock hold count to
955 * one.
956 *
957 * <p>If the current thread already holds this lock then the
958 * hold count is incremented by one and the method returns
959 * immediately.
960 *
961 * <p>If the lock is held by another thread then the current
962 * thread becomes disabled for thread scheduling purposes and
963 * lies dormant until one of two things happens:
964 *
965 * <ul>
966 *
967 * <li>The write lock is acquired by the current thread; or
968 *
969 * <li>Some other thread {@linkplain Thread#interrupt interrupts}
970 * the current thread.
971 *
972 * </ul>
973 *
974 * <p>If the write lock is acquired by the current thread then the
975 * lock hold count is set to one.
976 *
977 * <p>If the current thread:
978 *
979 * <ul>
980 *
981 * <li>has its interrupted status set on entry to this method;
982 * or
983 *
984 * <li>is {@linkplain Thread#interrupt interrupted} while
985 * acquiring the write lock,
986 *
987 * </ul>
988 *
989 * then {@link InterruptedException} is thrown and the current
990 * thread's interrupted status is cleared.
991 *
992 * <p>In this implementation, as this method is an explicit
993 * interruption point, preference is given to responding to
994 * the interrupt over normal or reentrant acquisition of the
995 * lock.
996 *
997 * @throws InterruptedException if the current thread is interrupted
998 */
999 public void lockInterruptibly() throws InterruptedException {
1000 sync.acquireInterruptibly(1);
1001 }
1002
1003 /**
1004 * Acquires the write lock only if it is not held by another thread
1005 * at the time of invocation.
1006 *
1007 * <p>Acquires the write lock if neither the read nor write lock
1008 * are held by another thread
1009 * and returns immediately with the value {@code true},
1010 * setting the write lock hold count to one. Even when this lock has
1011 * been set to use a fair ordering policy, a call to
1012 * {@code tryLock()} <em>will</em> immediately acquire the
1013 * lock if it is available, whether or not other threads are
1014 * currently waiting for the write lock. This "barging"
1015 * behavior can be useful in certain circumstances, even
1016 * though it breaks fairness. If you want to honor the
1017 * fairness setting for this lock, then use {@link
1018 * #tryLock(long, TimeUnit) tryLock(0, TimeUnit.SECONDS) }
1019 * which is almost equivalent (it also detects interruption).
1020 *
1021 * <p> If the current thread already holds this lock then the
1022 * hold count is incremented by one and the method returns
1023 * {@code true}.
1024 *
1025 * <p>If the lock is held by another thread then this method
1026 * will return immediately with the value {@code false}.
1027 *
1028 * @return {@code true} if the lock was free and was acquired
1029 * by the current thread, or the write lock was already held
1030 * by the current thread; and {@code false} otherwise.
1031 */
1032 public boolean tryLock( ) {
1033 return sync.tryWriteLock();
1034 }
1035
1036 /**
1037 * Acquires the write lock if it is not held by another thread
1038 * within the given waiting time and the current thread has
1039 * not been {@linkplain Thread#interrupt interrupted}.
1040 *
1041 * <p>Acquires the write lock if neither the read nor write lock
1042 * are held by another thread
1043 * and returns immediately with the value {@code true},
1044 * setting the write lock hold count to one. If this lock has been
1045 * set to use a fair ordering policy then an available lock
1046 * <em>will not</em> be acquired if any other threads are
1047 * waiting for the write lock. This is in contrast to the {@link
1048 * #tryLock()} method. If you want a timed {@code tryLock}
1049 * that does permit barging on a fair lock then combine the
1050 * timed and un-timed forms together:
1051 *
1052 * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
1053 * </pre>
1054 *
1055 * <p>If the current thread already holds this lock then the
1056 * hold count is incremented by one and the method returns
1057 * {@code true}.
1058 *
1059 * <p>If the lock is held by another thread then the current
1060 * thread becomes disabled for thread scheduling purposes and
1061 * lies dormant until one of three things happens:
1062 *
1063 * <ul>
1064 *
1065 * <li>The write lock is acquired by the current thread; or
1066 *
1067 * <li>Some other thread {@linkplain Thread#interrupt interrupts}
1068 * the current thread; or
1069 *
1070 * <li>The specified waiting time elapses
1071 *
1072 * </ul>
1073 *
1074 * <p>If the write lock is acquired then the value {@code true} is
1075 * returned and the write lock hold count is set to one.
1076 *
1077 * <p>If the current thread:
1078 *
1079 * <ul>
1080 *
1081 * <li>has its interrupted status set on entry to this method;
1082 * or
1083 *
1084 * <li>is {@linkplain Thread#interrupt interrupted} while
1085 * acquiring the write lock,
1086 *
1087 * </ul>
1088 *
1089 * then {@link InterruptedException} is thrown and the current
1090 * thread's interrupted status is cleared.
1091 *
1092 * <p>If the specified waiting time elapses then the value
1093 * {@code false} is returned. If the time is less than or
1094 * equal to zero, the method will not wait at all.
1095 *
1096 * <p>In this implementation, as this method is an explicit
1097 * interruption point, preference is given to responding to
1098 * the interrupt over normal or reentrant acquisition of the
1099 * lock, and over reporting the elapse of the waiting time.
1100 *
1101 * @param timeout the time to wait for the write lock
1102 * @param unit the time unit of the timeout argument
1103 *
1104 * @return {@code true} if the lock was free and was acquired
1105 * by the current thread, or the write lock was already held by the
1106 * current thread; and {@code false} if the waiting time
1107 * elapsed before the lock could be acquired.
1108 *
1109 * @throws InterruptedException if the current thread is interrupted
1110 * @throws NullPointerException if the time unit is null
1111 *
1112 */
1113 public boolean tryLock(long timeout, TimeUnit unit)
1114 throws InterruptedException {
1115 return sync.tryAcquireNanos(1, unit.toNanos(timeout));
1116 }
1117
1118 /**
1119 * Attempts to release this lock.
1120 *
1121 * <p>If the current thread is the holder of this lock then
1122 * the hold count is decremented. If the hold count is now
1123 * zero then the lock is released. If the current thread is
1124 * not the holder of this lock then {@link
1125 * IllegalMonitorStateException} is thrown.
1126 *
1127 * @throws IllegalMonitorStateException if the current thread does not
1128 * hold this lock.
1129 */
1130 public void unlock() {
1131 sync.release(1);
1132 }
1133
1134 /**
1135 * Returns a {@link Condition} instance for use with this
1136 * {@link Lock} instance.
1137 * <p>The returned {@link Condition} instance supports the same
1138 * usages as do the {@link Object} monitor methods ({@link
1139 * Object#wait() wait}, {@link Object#notify notify}, and {@link
1140 * Object#notifyAll notifyAll}) when used with the built-in
1141 * monitor lock.
1142 *
1143 * <ul>
1144 *
1145 * <li>If this write lock is not held when any {@link
1146 * Condition} method is called then an {@link
1147 * IllegalMonitorStateException} is thrown. (Read locks are
1148 * held independently of write locks, so are not checked or
1149 * affected. However it is essentially always an error to
1150 * invoke a condition waiting method when the current thread
1151 * has also acquired read locks, since other threads that
1152 * could unblock it will not be able to acquire the write
1153 * lock.)
1154 *
1155 * <li>When the condition {@linkplain Condition#await() waiting}
1156 * methods are called the write lock is released and, before
1157 * they return, the write lock is reacquired and the lock hold
1158 * count restored to what it was when the method was called.
1159 *
1160 * <li>If a thread is {@linkplain Thread#interrupt interrupted} while
1161 * waiting then the wait will terminate, an {@link
1162 * InterruptedException} will be thrown, and the thread's
1163 * interrupted status will be cleared.
1164 *
1165 * <li> Waiting threads are signalled in FIFO order.
1166 *
1167 * <li>The ordering of lock reacquisition for threads returning
1168 * from waiting methods is the same as for threads initially
1169 * acquiring the lock, which is in the default case not specified,
1170 * but for <em>fair</em> locks favors those threads that have been
1171 * waiting the longest.
1172 *
1173 * </ul>
1174 *
1175 * @return the Condition object
1176 */
1177 public Condition newCondition() {
1178 return sync.newCondition();
1179 }
1180
1181 /**
1182 * Returns a string identifying this lock, as well as its lock
1183 * state. The state, in brackets includes either the String
1184 * {@code "Unlocked"} or the String {@code "Locked by"}
1185 * followed by the {@linkplain Thread#getName name} of the owning thread.
1186 *
1187 * @return a string identifying this lock, as well as its lock state
1188 */
1189 public String toString() {
1190 Thread o = sync.getOwner();
1191 return super.toString() + ((o == null) ?
1192 "[Unlocked]" :
1193 "[Locked by thread " + o.getName() + "]");
1194 }
1195
1196 /**
1197 * Queries if this write lock is held by the current thread.
1198 * Identical in effect to {@link
1199 * ReentrantReadWriteLock#isWriteLockedByCurrentThread}.
1200 *
1201 * @return {@code true} if the current thread holds this lock and
1202 * {@code false} otherwise
1203 * @since 1.6
1204 */
1205 public boolean isHeldByCurrentThread() {
1206 return sync.isHeldExclusively();
1207 }
1208
1209 /**
1210 * Queries the number of holds on this write lock by the current
1211 * thread. A thread has a hold on a lock for each lock action
1212 * that is not matched by an unlock action. Identical in effect
1213 * to {@link ReentrantReadWriteLock#getWriteHoldCount}.
1214 *
1215 * @return the number of holds on this lock by the current thread,
1216 * or zero if this lock is not held by the current thread
1217 * @since 1.6
1218 */
1219 public int getHoldCount() {
1220 return sync.getWriteHoldCount();
1221 }
1222 }
1223
1224 // Instrumentation and status
1225
1226 /**
1227 * Returns {@code true} if this lock has fairness set true.
1228 *
1229 * @return {@code true} if this lock has fairness set true
1230 */
1231 public final boolean isFair() {
1232 return sync instanceof FairSync;
1233 }
1234
1235 /**
1236 * Returns the thread that currently owns the write lock, or
1237 * {@code null} if not owned. When this method is called by a
1238 * thread that is not the owner, the return value reflects a
1239 * best-effort approximation of current lock status. For example,
1240 * the owner may be momentarily {@code null} even if there are
1241 * threads trying to acquire the lock but have not yet done so.
1242 * This method is designed to facilitate construction of
1243 * subclasses that provide more extensive lock monitoring
1244 * facilities.
1245 *
1246 * @return the owner, or {@code null} if not owned
1247 */
1248 protected Thread getOwner() {
1249 return sync.getOwner();
1250 }
1251
1252 /**
1253 * Queries the number of read locks held for this lock. This
1254 * method is designed for use in monitoring system state, not for
1255 * synchronization control.
1256 * @return the number of read locks held.
1257 */
1258 public int getReadLockCount() {
1259 return sync.getReadLockCount();
1260 }
1261
1262 /**
1263 * Queries if the write lock is held by any thread. This method is
1264 * designed for use in monitoring system state, not for
1265 * synchronization control.
1266 *
1267 * @return {@code true} if any thread holds the write lock and
1268 * {@code false} otherwise
1269 */
1270 public boolean isWriteLocked() {
1271 return sync.isWriteLocked();
1272 }
1273
1274 /**
1275 * Queries if the write lock is held by the current thread.
1276 *
1277 * @return {@code true} if the current thread holds the write lock and
1278 * {@code false} otherwise
1279 */
1280 public boolean isWriteLockedByCurrentThread() {
1281 return sync.isHeldExclusively();
1282 }
1283
1284 /**
1285 * Queries the number of reentrant write holds on this lock by the
1286 * current thread. A writer thread has a hold on a lock for
1287 * each lock action that is not matched by an unlock action.
1288 *
1289 * @return the number of holds on the write lock by the current thread,
1290 * or zero if the write lock is not held by the current thread
1291 */
1292 public int getWriteHoldCount() {
1293 return sync.getWriteHoldCount();
1294 }
1295
1296 /**
1297 * Queries the number of reentrant read holds on this lock by the
1298 * current thread. A reader thread has a hold on a lock for
1299 * each lock action that is not matched by an unlock action.
1300 *
1301 * @return the number of holds on the read lock by the current thread,
1302 * or zero if the read lock is not held by the current thread
1303 * @since 1.6
1304 */
1305 public int getReadHoldCount() {
1306 return sync.getReadHoldCount();
1307 }
1308
1309 /**
1310 * Returns a collection containing threads that may be waiting to
1311 * acquire the write lock. Because the actual set of threads may
1312 * change dynamically while constructing this result, the returned
1313 * collection is only a best-effort estimate. The elements of the
1314 * returned collection are in no particular order. This method is
1315 * designed to facilitate construction of subclasses that provide
1316 * more extensive lock monitoring facilities.
1317 *
1318 * @return the collection of threads
1319 */
1320 protected Collection<Thread> getQueuedWriterThreads() {
1321 return sync.getExclusiveQueuedThreads();
1322 }
1323
1324 /**
1325 * Returns a collection containing threads that may be waiting to
1326 * acquire the read lock. Because the actual set of threads may
1327 * change dynamically while constructing this result, the returned
1328 * collection is only a best-effort estimate. The elements of the
1329 * returned collection are in no particular order. This method is
1330 * designed to facilitate construction of subclasses that provide
1331 * more extensive lock monitoring facilities.
1332 *
1333 * @return the collection of threads
1334 */
1335 protected Collection<Thread> getQueuedReaderThreads() {
1336 return sync.getSharedQueuedThreads();
1337 }
1338
1339 /**
1340 * Queries whether any threads are waiting to acquire the read or
1341 * write lock. Note that because cancellations may occur at any
1342 * time, a {@code true} return does not guarantee that any other
1343 * thread will ever acquire a lock. This method is designed
1344 * primarily for use in monitoring of the system state.
1345 *
1346 * @return {@code true} if there may be other threads waiting to
1347 * acquire the lock
1348 */
1349 public final boolean hasQueuedThreads() {
1350 return sync.hasQueuedThreads();
1351 }
1352
1353 /**
1354 * Queries whether the given thread is waiting to acquire either
1355 * the read or write lock. Note that because cancellations may
1356 * occur at any time, a {@code true} return does not guarantee
1357 * that this thread will ever acquire a lock. This method is
1358 * designed primarily for use in monitoring of the system state.
1359 *
1360 * @param thread the thread
1361 * @return {@code true} if the given thread is queued waiting for this lock
1362 * @throws NullPointerException if the thread is null
1363 */
1364 public final boolean hasQueuedThread(Thread thread) {
1365 return sync.isQueued(thread);
1366 }
1367
1368 /**
1369 * Returns an estimate of the number of threads waiting to acquire
1370 * either the read or write lock. The value is only an estimate
1371 * because the number of threads may change dynamically while this
1372 * method traverses internal data structures. This method is
1373 * designed for use in monitoring of the system state, not for
1374 * synchronization control.
1375 *
1376 * @return the estimated number of threads waiting for this lock
1377 */
1378 public final int getQueueLength() {
1379 return sync.getQueueLength();
1380 }
1381
1382 /**
1383 * Returns a collection containing threads that may be waiting to
1384 * acquire either the read or write lock. Because the actual set
1385 * of threads may change dynamically while constructing this
1386 * result, the returned collection is only a best-effort estimate.
1387 * The elements of the returned collection are in no particular
1388 * order. This method is designed to facilitate construction of
1389 * subclasses that provide more extensive monitoring facilities.
1390 *
1391 * @return the collection of threads
1392 */
1393 protected Collection<Thread> getQueuedThreads() {
1394 return sync.getQueuedThreads();
1395 }
1396
1397 /**
1398 * Queries whether any threads are waiting on the given condition
1399 * associated with the write lock. Note that because timeouts and
1400 * interrupts may occur at any time, a {@code true} return does
1401 * not guarantee that a future {@code signal} will awaken any
1402 * threads. This method is designed primarily for use in
1403 * monitoring of the system state.
1404 *
1405 * @param condition the condition
1406 * @return {@code true} if there are any waiting threads
1407 * @throws IllegalMonitorStateException if this lock is not held
1408 * @throws IllegalArgumentException if the given condition is
1409 * not associated with this lock
1410 * @throws NullPointerException if the condition is null
1411 */
1412 public boolean hasWaiters(Condition condition) {
1413 if (condition == null)
1414 throw new NullPointerException();
1415 if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
1416 throw new IllegalArgumentException("not owner");
1417 return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
1418 }
1419
1420 /**
1421 * Returns an estimate of the number of threads waiting on the
1422 * given condition associated with the write lock. Note that because
1423 * timeouts and interrupts may occur at any time, the estimate
1424 * serves only as an upper bound on the actual number of waiters.
1425 * This method is designed for use in monitoring of the system
1426 * state, not for synchronization control.
1427 *
1428 * @param condition the condition
1429 * @return the estimated number of waiting threads
1430 * @throws IllegalMonitorStateException if this lock is not held
1431 * @throws IllegalArgumentException if the given condition is
1432 * not associated with this lock
1433 * @throws NullPointerException if the condition is null
1434 */
1435 public int getWaitQueueLength(Condition condition) {
1436 if (condition == null)
1437 throw new NullPointerException();
1438 if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
1439 throw new IllegalArgumentException("not owner");
1440 return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
1441 }
1442
1443 /**
1444 * Returns a collection containing those threads that may be
1445 * waiting on the given condition associated with the write lock.
1446 * Because the actual set of threads may change dynamically while
1447 * constructing this result, the returned collection is only a
1448 * best-effort estimate. The elements of the returned collection
1449 * are in no particular order. This method is designed to
1450 * facilitate construction of subclasses that provide more
1451 * extensive condition monitoring facilities.
1452 *
1453 * @param condition the condition
1454 * @return the collection of threads
1455 * @throws IllegalMonitorStateException if this lock is not held
1456 * @throws IllegalArgumentException if the given condition is
1457 * not associated with this lock
1458 * @throws NullPointerException if the condition is null
1459 */
1460 protected Collection<Thread> getWaitingThreads(Condition condition) {
1461 if (condition == null)
1462 throw new NullPointerException();
1463 if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
1464 throw new IllegalArgumentException("not owner");
1465 return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
1466 }
1467
1468 /**
1469 * Returns a string identifying this lock, as well as its lock state.
1470 * The state, in brackets, includes the String {@code "Write locks ="}
1471 * followed by the number of reentrantly held write locks, and the
1472 * String {@code "Read locks ="} followed by the number of held
1473 * read locks.
1474 *
1475 * @return a string identifying this lock, as well as its lock state
1476 */
1477 public String toString() {
1478 int c = sync.getCount();
1479 int w = Sync.exclusiveCount(c);
1480 int r = Sync.sharedCount(c);
1481
1482 return super.toString() +
1483 "[Write locks = " + w + ", Read locks = " + r + "]";
1484 }
1485
1486 }
AQS的完整源码
1 /*
2 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
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 * Written by Doug Lea with assistance from members of JCP JSR-166
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36 package java.util.concurrent.locks;
37 import java.util.*;
38 import java.util.concurrent.*;
39 import java.util.concurrent.atomic.*;
40 import sun.misc.Unsafe;
41
42 /**
43 * Provides a framework for implementing blocking locks and related
44 * synchronizers (semaphores, events, etc) that rely on
45 * first-in-first-out (FIFO) wait queues. This class is designed to
46 * be a useful basis for most kinds of synchronizers that rely on a
47 * single atomic <tt>int</tt> value to represent state. Subclasses
48 * must define the protected methods that change this state, and which
49 * define what that state means in terms of this object being acquired
50 * or released. Given these, the other methods in this class carry
51 * out all queuing and blocking mechanics. Subclasses can maintain
52 * other state fields, but only the atomically updated <tt>int</tt>
53 * value manipulated using methods {@link #getState}, {@link
54 * #setState} and {@link #compareAndSetState} is tracked with respect
55 * to synchronization.
56 *
57 * <p>Subclasses should be defined as non-public internal helper
58 * classes that are used to implement the synchronization properties
59 * of their enclosing class. Class
60 * <tt>AbstractQueuedSynchronizer</tt> does not implement any
61 * synchronization interface. Instead it defines methods such as
62 * {@link #acquireInterruptibly} that can be invoked as
63 * appropriate by concrete locks and related synchronizers to
64 * implement their public methods.
65 *
66 * <p>This class supports either or both a default <em>exclusive</em>
67 * mode and a <em>shared</em> mode. When acquired in exclusive mode,
68 * attempted acquires by other threads cannot succeed. Shared mode
69 * acquires by multiple threads may (but need not) succeed. This class
70 * does not "understand" these differences except in the
71 * mechanical sense that when a shared mode acquire succeeds, the next
72 * waiting thread (if one exists) must also determine whether it can
73 * acquire as well. Threads waiting in the different modes share the
74 * same FIFO queue. Usually, implementation subclasses support only
75 * one of these modes, but both can come into play for example in a
76 * {@link ReadWriteLock}. Subclasses that support only exclusive or
77 * only shared modes need not define the methods supporting the unused mode.
78 *
79 * <p>This class defines a nested {@link ConditionObject} class that
80 * can be used as a {@link Condition} implementation by subclasses
81 * supporting exclusive mode for which method {@link
82 * #isHeldExclusively} reports whether synchronization is exclusively
83 * held with respect to the current thread, method {@link #release}
84 * invoked with the current {@link #getState} value fully releases
85 * this object, and {@link #acquire}, given this saved state value,
86 * eventually restores this object to its previous acquired state. No
87 * <tt>AbstractQueuedSynchronizer</tt> method otherwise creates such a
88 * condition, so if this constraint cannot be met, do not use it. The
89 * behavior of {@link ConditionObject} depends of course on the
90 * semantics of its synchronizer implementation.
91 *
92 * <p>This class provides inspection, instrumentation, and monitoring
93 * methods for the internal queue, as well as similar methods for
94 * condition objects. These can be exported as desired into classes
95 * using an <tt>AbstractQueuedSynchronizer</tt> for their
96 * synchronization mechanics.
97 *
98 * <p>Serialization of this class stores only the underlying atomic
99 * integer maintaining state, so deserialized objects have empty
100 * thread queues. Typical subclasses requiring serializability will
101 * define a <tt>readObject</tt> method that restores this to a known
102 * initial state upon deserialization.
103 *
104 * <h3>Usage</h3>
105 *
106 * <p>To use this class as the basis of a synchronizer, redefine the
107 * following methods, as applicable, by inspecting and/or modifying
108 * the synchronization state using {@link #getState}, {@link
109 * #setState} and/or {@link #compareAndSetState}:
110 *
111 * <ul>
112 * <li> {@link #tryAcquire}
113 * <li> {@link #tryRelease}
114 * <li> {@link #tryAcquireShared}
115 * <li> {@link #tryReleaseShared}
116 * <li> {@link #isHeldExclusively}
117 *</ul>
118 *
119 * Each of these methods by default throws {@link
120 * UnsupportedOperationException}. Implementations of these methods
121 * must be internally thread-safe, and should in general be short and
122 * not block. Defining these methods is the <em>only</em> supported
123 * means of using this class. All other methods are declared
124 * <tt>final</tt> because they cannot be independently varied.
125 *
126 * <p>You may also find the inherited methods from {@link
127 * AbstractOwnableSynchronizer} useful to keep track of the thread
128 * owning an exclusive synchronizer. You are encouraged to use them
129 * -- this enables monitoring and diagnostic tools to assist users in
130 * determining which threads hold locks.
131 *
132 * <p>Even though this class is based on an internal FIFO queue, it
133 * does not automatically enforce FIFO acquisition policies. The core
134 * of exclusive synchronization takes the form:
135 *
136 * <pre>
137 * Acquire:
138 * while (!tryAcquire(arg)) {
139 * <em>enqueue thread if it is not already queued</em>;
140 * <em>possibly block current thread</em>;
141 * }
142 *
143 * Release:
144 * if (tryRelease(arg))
145 * <em>unblock the first queued thread</em>;
146 * </pre>
147 *
148 * (Shared mode is similar but may involve cascading signals.)
149 *
150 * <p><a name="barging">Because checks in acquire are invoked before
151 * enqueuing, a newly acquiring thread may <em>barge</em> ahead of
152 * others that are blocked and queued. However, you can, if desired,
153 * define <tt>tryAcquire</tt> and/or <tt>tryAcquireShared</tt> to
154 * disable barging by internally invoking one or more of the inspection
155 * methods, thereby providing a <em>fair</em> FIFO acquisition order.
156 * In particular, most fair synchronizers can define <tt>tryAcquire</tt>
157 * to return <tt>false</tt> if {@link #hasQueuedPredecessors} (a method
158 * specifically designed to be used by fair synchronizers) returns
159 * <tt>true</tt>. Other variations are possible.
160 *
161 * <p>Throughput and scalability are generally highest for the
162 * default barging (also known as <em>greedy</em>,
163 * <em>renouncement</em>, and <em>convoy-avoidance</em>) strategy.
164 * While this is not guaranteed to be fair or starvation-free, earlier
165 * queued threads are allowed to recontend before later queued
166 * threads, and each recontention has an unbiased chance to succeed
167 * against incoming threads. Also, while acquires do not
168 * "spin" in the usual sense, they may perform multiple
169 * invocations of <tt>tryAcquire</tt> interspersed with other
170 * computations before blocking. This gives most of the benefits of
171 * spins when exclusive synchronization is only briefly held, without
172 * most of the liabilities when it isn't. If so desired, you can
173 * augment this by preceding calls to acquire methods with
174 * "fast-path" checks, possibly prechecking {@link #hasContended}
175 * and/or {@link #hasQueuedThreads} to only do so if the synchronizer
176 * is likely not to be contended.
177 *
178 * <p>This class provides an efficient and scalable basis for
179 * synchronization in part by specializing its range of use to
180 * synchronizers that can rely on <tt>int</tt> state, acquire, and
181 * release parameters, and an internal FIFO wait queue. When this does
182 * not suffice, you can build synchronizers from a lower level using
183 * {@link java.util.concurrent.atomic atomic} classes, your own custom
184 * {@link java.util.Queue} classes, and {@link LockSupport} blocking
185 * support.
186 *
187 * <h3>Usage Examples</h3>
188 *
189 * <p>Here is a non-reentrant mutual exclusion lock class that uses
190 * the value zero to represent the unlocked state, and one to
191 * represent the locked state. While a non-reentrant lock
192 * does not strictly require recording of the current owner
193 * thread, this class does so anyway to make usage easier to monitor.
194 * It also supports conditions and exposes
195 * one of the instrumentation methods:
196 *
197 * <pre>
198 * class Mutex implements Lock, java.io.Serializable {
199 *
200 * // Our internal helper class
201 * private static class Sync extends AbstractQueuedSynchronizer {
202 * // Report whether in locked state
203 * protected boolean isHeldExclusively() {
204 * return getState() == 1;
205 * }
206 *
207 * // Acquire the lock if state is zero
208 * public boolean tryAcquire(int acquires) {
209 * assert acquires == 1; // Otherwise unused
210 * if (compareAndSetState(0, 1)) {
211 * setExclusiveOwnerThread(Thread.currentThread());
212 * return true;
213 * }
214 * return false;
215 * }
216 *
217 * // Release the lock by setting state to zero
218 * protected boolean tryRelease(int releases) {
219 * assert releases == 1; // Otherwise unused
220 * if (getState() == 0) throw new IllegalMonitorStateException();
221 * setExclusiveOwnerThread(null);
222 * setState(0);
223 * return true;
224 * }
225 *
226 * // Provide a Condition
227 * Condition newCondition() { return new ConditionObject(); }
228 *
229 * // Deserialize properly
230 * private void readObject(ObjectInputStream s)
231 * throws IOException, ClassNotFoundException {
232 * s.defaultReadObject();
233 * setState(0); // reset to unlocked state
234 * }
235 * }
236 *
237 * // The sync object does all the hard work. We just forward to it.
238 * private final Sync sync = new Sync();
239 *
240 * public void lock() { sync.acquire(1); }
241 * public boolean tryLock() { return sync.tryAcquire(1); }
242 * public void unlock() { sync.release(1); }
243 * public Condition newCondition() { return sync.newCondition(); }
244 * public boolean isLocked() { return sync.isHeldExclusively(); }
245 * public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
246 * public void lockInterruptibly() throws InterruptedException {
247 * sync.acquireInterruptibly(1);
248 * }
249 * public boolean tryLock(long timeout, TimeUnit unit)
250 * throws InterruptedException {
251 * return sync.tryAcquireNanos(1, unit.toNanos(timeout));
252 * }
253 * }
254 * </pre>
255 *
256 * <p>Here is a latch class that is like a {@link CountDownLatch}
257 * except that it only requires a single <tt>signal</tt> to
258 * fire. Because a latch is non-exclusive, it uses the <tt>shared</tt>
259 * acquire and release methods.
260 *
261 * <pre>
262 * class BooleanLatch {
263 *
264 * private static class Sync extends AbstractQueuedSynchronizer {
265 * boolean isSignalled() { return getState() != 0; }
266 *
267 * protected int tryAcquireShared(int ignore) {
268 * return isSignalled() ? 1 : -1;
269 * }
270 *
271 * protected boolean tryReleaseShared(int ignore) {
272 * setState(1);
273 * return true;
274 * }
275 * }
276 *
277 * private final Sync sync = new Sync();
278 * public boolean isSignalled() { return sync.isSignalled(); }
279 * public void signal() { sync.releaseShared(1); }
280 * public void await() throws InterruptedException {
281 * sync.acquireSharedInterruptibly(1);
282 * }
283 * }
284 * </pre>
285 *
286 * @since 1.5
287 * @author Doug Lea
288 */
289 public abstract class AbstractQueuedSynchronizer
290 extends AbstractOwnableSynchronizer
291 implements java.io.Serializable {
292
293 private static final long serialVersionUID = 7373984972572414691L;
294
295 /**
296 * Creates a new <tt>AbstractQueuedSynchronizer</tt> instance
297 * with initial synchronization state of zero.
298 */
299 protected AbstractQueuedSynchronizer() { }
300
301 /**
302 * Wait queue node class.
303 *
304 * <p>The wait queue is a variant of a "CLH" (Craig, Landin, and
305 * Hagersten) lock queue. CLH locks are normally used for
306 * spinlocks. We instead use them for blocking synchronizers, but
307 * use the same basic tactic of holding some of the control
308 * information about a thread in the predecessor of its node. A
309 * "status" field in each node keeps track of whether a thread
310 * should block. A node is signalled when its predecessor
311 * releases. Each node of the queue otherwise serves as a
312 * specific-notification-style monitor holding a single waiting
313 * thread. The status field does NOT control whether threads are
314 * granted locks etc though. A thread may try to acquire if it is
315 * first in the queue. But being first does not guarantee success;
316 * it only gives the right to contend. So the currently released
317 * contender thread may need to rewait.
318 *
319 * <p>To enqueue into a CLH lock, you atomically splice it in as new
320 * tail. To dequeue, you just set the head field.
321 * <pre>
322 * +------+ prev +-----+ +-----+
323 * head | | <---- | | <---- | | tail
324 * +------+ +-----+ +-----+
325 * </pre>
326 *
327 * <p>Insertion into a CLH queue requires only a single atomic
328 * operation on "tail", so there is a simple atomic point of
329 * demarcation from unqueued to queued. Similarly, dequeing
330 * involves only updating the "head". However, it takes a bit
331 * more work for nodes to determine who their successors are,
332 * in part to deal with possible cancellation due to timeouts
333 * and interrupts.
334 *
335 * <p>The "prev" links (not used in original CLH locks), are mainly
336 * needed to handle cancellation. If a node is cancelled, its
337 * successor is (normally) relinked to a non-cancelled
338 * predecessor. For explanation of similar mechanics in the case
339 * of spin locks, see the papers by Scott and Scherer at
340 * http://www.cs.rochester.edu/u/scott/synchronization/
341 *
342 * <p>We also use "next" links to implement blocking mechanics.
343 * The thread id for each node is kept in its own node, so a
344 * predecessor signals the next node to wake up by traversing
345 * next link to determine which thread it is. Determination of
346 * successor must avoid races with newly queued nodes to set
347 * the "next" fields of their predecessors. This is solved
348 * when necessary by checking backwards from the atomically
349 * updated "tail" when a node's successor appears to be null.
350 * (Or, said differently, the next-links are an optimization
351 * so that we don't usually need a backward scan.)
352 *
353 * <p>Cancellation introduces some conservatism to the basic
354 * algorithms. Since we must poll for cancellation of other
355 * nodes, we can miss noticing whether a cancelled node is
356 * ahead or behind us. This is dealt with by always unparking
357 * successors upon cancellation, allowing them to stabilize on
358 * a new predecessor, unless we can identify an uncancelled
359 * predecessor who will carry this responsibility.
360 *
361 * <p>CLH queues need a dummy header node to get started. But
362 * we don't create them on construction, because it would be wasted
363 * effort if there is never contention. Instead, the node
364 * is constructed and head and tail pointers are set upon first
365 * contention.
366 *
367 * <p>Threads waiting on Conditions use the same nodes, but
368 * use an additional link. Conditions only need to link nodes
369 * in simple (non-concurrent) linked queues because they are
370 * only accessed when exclusively held. Upon await, a node is
371 * inserted into a condition queue. Upon signal, the node is
372 * transferred to the main queue. A special value of status
373 * field is used to mark which queue a node is on.
374 *
375 * <p>Thanks go to Dave Dice, Mark Moir, Victor Luchangco, Bill
376 * Scherer and Michael Scott, along with members of JSR-166
377 * expert group, for helpful ideas, discussions, and critiques
378 * on the design of this class.
379 */
380 static final class Node {
381 /** Marker to indicate a node is waiting in shared mode */
382 static final Node SHARED = new Node();
383 /** Marker to indicate a node is waiting in exclusive mode */
384 static final Node EXCLUSIVE = null;
385
386 /** waitStatus value to indicate thread has cancelled */
387 static final int CANCELLED = 1;
388 /** waitStatus value to indicate successor's thread needs unparking */
389 static final int SIGNAL = -1;
390 /** waitStatus value to indicate thread is waiting on condition */
391 static final int CONDITION = -2;
392 /**
393 * waitStatus value to indicate the next acquireShared should
394 * unconditionally propagate
395 */
396 static final int PROPAGATE = -3;
397
398 /**
399 * Status field, taking on only the values:
400 * SIGNAL: The successor of this node is (or will soon be)
401 * blocked (via park), so the current node must
402 * unpark its successor when it releases or
403 * cancels. To avoid races, acquire methods must
404 * first indicate they need a signal,
405 * then retry the atomic acquire, and then,
406 * on failure, block.
407 * CANCELLED: This node is cancelled due to timeout or interrupt.
408 * Nodes never leave this state. In particular,
409 * a thread with cancelled node never again blocks.
410 * CONDITION: This node is currently on a condition queue.
411 * It will not be used as a sync queue node
412 * until transferred, at which time the status
413 * will be set to 0. (Use of this value here has
414 * nothing to do with the other uses of the
415 * field, but simplifies mechanics.)
416 * PROPAGATE: A releaseShared should be propagated to other
417 * nodes. This is set (for head node only) in
418 * doReleaseShared to ensure propagation
419 * continues, even if other operations have
420 * since intervened.
421 * 0: None of the above
422 *
423 * The values are arranged numerically to simplify use.
424 * Non-negative values mean that a node doesn't need to
425 * signal. So, most code doesn't need to check for particular
426 * values, just for sign.
427 *
428 * The field is initialized to 0 for normal sync nodes, and
429 * CONDITION for condition nodes. It is modified using CAS
430 * (or when possible, unconditional volatile writes).
431 */
432 volatile int waitStatus;
433
434 /**
435 * Link to predecessor node that current node/thread relies on
436 * for checking waitStatus. Assigned during enqueing, and nulled
437 * out (for sake of GC) only upon dequeuing. Also, upon
438 * cancellation of a predecessor, we short-circuit while
439 * finding a non-cancelled one, which will always exist
440 * because the head node is never cancelled: A node becomes
441 * head only as a result of successful acquire. A
442 * cancelled thread never succeeds in acquiring, and a thread only
443 * cancels itself, not any other node.
444 */
445 volatile Node prev;
446
447 /**
448 * Link to the successor node that the current node/thread
449 * unparks upon release. Assigned during enqueuing, adjusted
450 * when bypassing cancelled predecessors, and nulled out (for
451 * sake of GC) when dequeued. The enq operation does not
452 * assign next field of a predecessor until after attachment,
453 * so seeing a null next field does not necessarily mean that
454 * node is at end of queue. However, if a next field appears
455 * to be null, we can scan prev's from the tail to
456 * double-check. The next field of cancelled nodes is set to
457 * point to the node itself instead of null, to make life
458 * easier for isOnSyncQueue.
459 */
460 volatile Node next;
461
462 /**
463 * The thread that enqueued this node. Initialized on
464 * construction and nulled out after use.
465 */
466 volatile Thread thread;
467
468 /**
469 * Link to next node waiting on condition, or the special
470 * value SHARED. Because condition queues are accessed only
471 * when holding in exclusive mode, we just need a simple
472 * linked queue to hold nodes while they are waiting on
473 * conditions. They are then transferred to the queue to
474 * re-acquire. And because conditions can only be exclusive,
475 * we save a field by using special value to indicate shared
476 * mode.
477 */
478 Node nextWaiter;
479
480 /**
481 * Returns true if node is waiting in shared mode
482 */
483 final boolean isShared() {
484 return nextWaiter == SHARED;
485 }
486
487 /**
488 * Returns previous node, or throws NullPointerException if null.
489 * Use when predecessor cannot be null. The null check could
490 * be elided, but is present to help the VM.
491 *
492 * @return the predecessor of this node
493 */
494 final Node predecessor() throws NullPointerException {
495 Node p = prev;
496 if (p == null)
497 throw new NullPointerException();
498 else
499 return p;
500 }
501
502 Node() { // Used to establish initial head or SHARED marker
503 }
504
505 Node(Thread thread, Node mode) { // Used by addWaiter
506 this.nextWaiter = mode;
507 this.thread = thread;
508 }
509
510 Node(Thread thread, int waitStatus) { // Used by Condition
511 this.waitStatus = waitStatus;
512 this.thread = thread;
513 }
514 }
515
516 /**
517 * Head of the wait queue, lazily initialized. Except for
518 * initialization, it is modified only via method setHead. Note:
519 * If head exists, its waitStatus is guaranteed not to be
520 * CANCELLED.
521 */
522 private transient volatile Node head;
523
524 /**
525 * Tail of the wait queue, lazily initialized. Modified only via
526 * method enq to add new wait node.
527 */
528 private transient volatile Node tail;
529
530 /**
531 * The synchronization state.
532 */
533 private volatile int state;
534
535 /**
536 * Returns the current value of synchronization state.
537 * This operation has memory semantics of a <tt>volatile</tt> read.
538 * @return current state value
539 */
540 protected final int getState() {
541 return state;
542 }
543
544 /**
545 * Sets the value of synchronization state.
546 * This operation has memory semantics of a <tt>volatile</tt> write.
547 * @param newState the new state value
548 */
549 protected final void setState(int newState) {
550 state = newState;
551 }
552
553 /**
554 * Atomically sets synchronization state to the given updated
555 * value if the current state value equals the expected value.
556 * This operation has memory semantics of a <tt>volatile</tt> read
557 * and write.
558 *
559 * @param expect the expected value
560 * @param update the new value
561 * @return true if successful. False return indicates that the actual
562 * value was not equal to the expected value.
563 */
564 protected final boolean compareAndSetState(int expect, int update) {
565 // See below for intrinsics setup to support this
566 return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
567 }
568
569 // Queuing utilities
570
571 /**
572 * The number of nanoseconds for which it is faster to spin
573 * rather than to use timed park. A rough estimate suffices
574 * to improve responsiveness with very short timeouts.
575 */
576 static final long spinForTimeoutThreshold = 1000L;
577
578 /**
579 * Inserts node into queue, initializing if necessary. See picture above.
580 * @param node the node to insert
581 * @return node's predecessor
582 */
583 private Node enq(final Node node) {
584 for (;;) {
585 Node t = tail;
586 if (t == null) { // Must initialize
587 if (compareAndSetHead(new Node()))
588 tail = head;
589 } else {
590 node.prev = t;
591 if (compareAndSetTail(t, node)) {
592 t.next = node;
593 return t;
594 }
595 }
596 }
597 }
598
599 /**
600 * Creates and enqueues node for current thread and given mode.
601 *
602 * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
603 * @return the new node
604 */
605 private Node addWaiter(Node mode) {
606 Node node = new Node(Thread.currentThread(), mode);
607 // Try the fast path of enq; backup to full enq on failure
608 Node pred = tail;
609 if (pred != null) {
610 node.prev = pred;
611 if (compareAndSetTail(pred, node)) {
612 pred.next = node;
613 return node;
614 }
615 }
616 enq(node);
617 return node;
618 }
619
620 /**
621 * Sets head of queue to be node, thus dequeuing. Called only by
622 * acquire methods. Also nulls out unused fields for sake of GC
623 * and to suppress unnecessary signals and traversals.
624 *
625 * @param node the node
626 */
627 private void setHead(Node node) {
628 head = node;
629 node.thread = null;
630 node.prev = null;
631 }
632
633 /**
634 * Wakes up node's successor, if one exists.
635 *
636 * @param node the node
637 */
638 private void unparkSuccessor(Node node) {
639 /*
640 * If status is negative (i.e., possibly needing signal) try
641 * to clear in anticipation of signalling. It is OK if this
642 * fails or if status is changed by waiting thread.
643 */
644 int ws = node.waitStatus;
645 if (ws < 0)
646 compareAndSetWaitStatus(node, ws, 0);
647
648 /*
649 * Thread to unpark is held in successor, which is normally
650 * just the next node. But if cancelled or apparently null,
651 * traverse backwards from tail to find the actual
652 * non-cancelled successor.
653 */
654 Node s = node.next;
655 if (s == null || s.waitStatus > 0) {
656 s = null;
657 for (Node t = tail; t != null && t != node; t = t.prev)
658 if (t.waitStatus <= 0)
659 s = t;
660 }
661 if (s != null)
662 LockSupport.unpark(s.thread);
663 }
664
665 /**
666 * Release action for shared mode -- signal successor and ensure
667 * propagation. (Note: For exclusive mode, release just amounts
668 * to calling unparkSuccessor of head if it needs signal.)
669 */
670 private void doReleaseShared() {
671 /*
672 * Ensure that a release propagates, even if there are other
673 * in-progress acquires/releases. This proceeds in the usual
674 * way of trying to unparkSuccessor of head if it needs
675 * signal. But if it does not, status is set to PROPAGATE to
676 * ensure that upon release, propagation continues.
677 * Additionally, we must loop in case a new node is added
678 * while we are doing this. Also, unlike other uses of
679 * unparkSuccessor, we need to know if CAS to reset status
680 * fails, if so rechecking.
681 */
682 for (;;) {
683 Node h = head;
684 if (h != null && h != tail) {
685 int ws = h.waitStatus;
686 if (ws == Node.SIGNAL) {
687 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
688 continue; // loop to recheck cases
689 unparkSuccessor(h);
690 }
691 else if (ws == 0 &&
692 !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
693 continue; // loop on failed CAS
694 }
695 if (h == head) // loop if head changed
696 break;
697 }
698 }
699
700 /**
701 * Sets head of queue, and checks if successor may be waiting
702 * in shared mode, if so propagating if either propagate > 0 or
703 * PROPAGATE status was set.
704 *
705 * @param node the node
706 * @param propagate the return value from a tryAcquireShared
707 */
708 private void setHeadAndPropagate(Node node, int propagate) {
709 Node h = head; // Record old head for check below
710 setHead(node);
711 /*
712 * Try to signal next queued node if:
713 * Propagation was indicated by caller,
714 * or was recorded (as h.waitStatus) by a previous operation
715 * (note: this uses sign-check of waitStatus because
716 * PROPAGATE status may transition to SIGNAL.)
717 * and
718 * The next node is waiting in shared mode,
719 * or we don't know, because it appears null
720 *
721 * The conservatism in both of these checks may cause
722 * unnecessary wake-ups, but only when there are multiple
723 * racing acquires/releases, so most need signals now or soon
724 * anyway.
725 */
726 if (propagate > 0 || h == null || h.waitStatus < 0) {
727 Node s = node.next;
728 if (s == null || s.isShared())
729 doReleaseShared();
730 }
731 }
732
733 // Utilities for various versions of acquire
734
735 /**
736 * Cancels an ongoing attempt to acquire.
737 *
738 * @param node the node
739 */
740 private void cancelAcquire(Node node) {
741 // Ignore if node doesn't exist
742 if (node == null)
743 return;
744
745 node.thread = null;
746
747 // Skip cancelled predecessors
748 Node pred = node.prev;
749 while (pred.waitStatus > 0)
750 node.prev = pred = pred.prev;
751
752 // predNext is the apparent node to unsplice. CASes below will
753 // fail if not, in which case, we lost race vs another cancel
754 // or signal, so no further action is necessary.
755 Node predNext = pred.next;
756
757 // Can use unconditional write instead of CAS here.
758 // After this atomic step, other Nodes can skip past us.
759 // Before, we are free of interference from other threads.
760 node.waitStatus = Node.CANCELLED;
761
762 // If we are the tail, remove ourselves.
763 if (node == tail && compareAndSetTail(node, pred)) {
764 compareAndSetNext(pred, predNext, null);
765 } else {
766 // If successor needs signal, try to set pred's next-link
767 // so it will get one. Otherwise wake it up to propagate.
768 int ws;
769 if (pred != head &&
770 ((ws = pred.waitStatus) == Node.SIGNAL ||
771 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
772 pred.thread != null) {
773 Node next = node.next;
774 if (next != null && next.waitStatus <= 0)
775 compareAndSetNext(pred, predNext, next);
776 } else {
777 unparkSuccessor(node);
778 }
779
780 node.next = node; // help GC
781 }
782 }
783
784 /**
785 * Checks and updates status for a node that failed to acquire.
786 * Returns true if thread should block. This is the main signal
787 * control in all acquire loops. Requires that pred == node.prev
788 *
789 * @param pred node's predecessor holding status
790 * @param node the node
791 * @return {@code true} if thread should block
792 */
793 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
794 int ws = pred.waitStatus;
795 if (ws == Node.SIGNAL)
796 /*
797 * This node has already set status asking a release
798 * to signal it, so it can safely park.
799 */
800 return true;
801 if (ws > 0) {
802 /*
803 * Predecessor was cancelled. Skip over predecessors and
804 * indicate retry.
805 */
806 do {
807 node.prev = pred = pred.prev;
808 } while (pred.waitStatus > 0);
809 pred.next = node;
810 } else {
811 /*
812 * waitStatus must be 0 or PROPAGATE. Indicate that we
813 * need a signal, but don't park yet. Caller will need to
814 * retry to make sure it cannot acquire before parking.
815 */
816 compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
817 }
818 return false;
819 }
820
821 /**
822 * Convenience method to interrupt current thread.
823 */
824 private static void selfInterrupt() {
825 Thread.currentThread().interrupt();
826 }
827
828 /**
829 * Convenience method to park and then check if interrupted
830 *
831 * @return {@code true} if interrupted
832 */
833 private final boolean parkAndCheckInterrupt() {
834 LockSupport.park(this);
835 return Thread.interrupted();
836 }
837
838 /*
839 * Various flavors of acquire, varying in exclusive/shared and
840 * control modes. Each is mostly the same, but annoyingly
841 * different. Only a little bit of factoring is possible due to
842 * interactions of exception mechanics (including ensuring that we
843 * cancel if tryAcquire throws exception) and other control, at
844 * least not without hurting performance too much.
845 */
846
847 /**
848 * Acquires in exclusive uninterruptible mode for thread already in
849 * queue. Used by condition wait methods as well as acquire.
850 *
851 * @param node the node
852 * @param arg the acquire argument
853 * @return {@code true} if interrupted while waiting
854 */
855 final boolean acquireQueued(final Node node, int arg) {
856 boolean failed = true;
857 try {
858 boolean interrupted = false;
859 for (;;) {
860 final Node p = node.predecessor();
861 if (p == head && tryAcquire(arg)) {
862 setHead(node);
863 p.next = null; // help GC
864 failed = false;
865 return interrupted;
866 }
867 if (shouldParkAfterFailedAcquire(p, node) &&
868 parkAndCheckInterrupt())
869 interrupted = true;
870 }
871 } finally {
872 if (failed)
873 cancelAcquire(node);
874 }
875 }
876
877 /**
878 * Acquires in exclusive interruptible mode.
879 * @param arg the acquire argument
880 */
881 private void doAcquireInterruptibly(int arg)
882 throws InterruptedException {
883 final Node node = addWaiter(Node.EXCLUSIVE);
884 boolean failed = true;
885 try {
886 for (;;) {
887 final Node p = node.predecessor();
888 if (p == head && tryAcquire(arg)) {
889 setHead(node);
890 p.next = null; // help GC
891 failed = false;
892 return;
893 }
894 if (shouldParkAfterFailedAcquire(p, node) &&
895 parkAndCheckInterrupt())
896 throw new InterruptedException();
897 }
898 } finally {
899 if (failed)
900 cancelAcquire(node);
901 }
902 }
903
904 /**
905 * Acquires in exclusive timed mode.
906 *
907 * @param arg the acquire argument
908 * @param nanosTimeout max wait time
909 * @return {@code true} if acquired
910 */
911 private boolean doAcquireNanos(int arg, long nanosTimeout)
912 throws InterruptedException {
913 long lastTime = System.nanoTime();
914 final Node node = addWaiter(Node.EXCLUSIVE);
915 boolean failed = true;
916 try {
917 for (;;) {
918 final Node p = node.predecessor();
919 if (p == head && tryAcquire(arg)) {
920 setHead(node);
921 p.next = null; // help GC
922 failed = false;
923 return true;
924 }
925 if (nanosTimeout <= 0)
926 return false;
927 if (shouldParkAfterFailedAcquire(p, node) &&
928 nanosTimeout > spinForTimeoutThreshold)
929 LockSupport.parkNanos(this, nanosTimeout);
930 long now = System.nanoTime();
931 nanosTimeout -= now - lastTime;
932 lastTime = now;
933 if (Thread.interrupted())
934 throw new InterruptedException();
935 }
936 } finally {
937 if (failed)
938 cancelAcquire(node);
939 }
940 }
941
942 /**
943 * Acquires in shared uninterruptible mode.
944 * @param arg the acquire argument
945 */
946 private void doAcquireShared(int arg) {
947 final Node node = addWaiter(Node.SHARED);
948 boolean failed = true;
949 try {
950 boolean interrupted = false;
951 for (;;) {
952 final Node p = node.predecessor();
953 if (p == head) {
954 int r = tryAcquireShared(arg);
955 if (r >= 0) {
956 setHeadAndPropagate(node, r);
957 p.next = null; // help GC
958 if (interrupted)
959 selfInterrupt();
960 failed = false;
961 return;
962 }
963 }
964 if (shouldParkAfterFailedAcquire(p, node) &&
965 parkAndCheckInterrupt())
966 interrupted = true;
967 }
968 } finally {
969 if (failed)
970 cancelAcquire(node);
971 }
972 }
973
974 /**
975 * Acquires in shared interruptible mode.
976 * @param arg the acquire argument
977 */
978 private void doAcquireSharedInterruptibly(int arg)
979 throws InterruptedException {
980 final Node node = addWaiter(Node.SHARED);
981 boolean failed = true;
982 try {
983 for (;;) {
984 final Node p = node.predecessor();
985 if (p == head) {
986 int r = tryAcquireShared(arg);
987 if (r >= 0) {
988 setHeadAndPropagate(node, r);
989 p.next = null; // help GC
990 failed = false;
991 return;
992 }
993 }
994 if (shouldParkAfterFailedAcquire(p, node) &&
995 parkAndCheckInterrupt())
996 throw new InterruptedException();
997 }
998 } finally {
999 if (failed)
1000 cancelAcquire(node);
1001 }
1002 }
1003
1004 /**
1005 * Acquires in shared timed mode.
1006 *
1007 * @param arg the acquire argument
1008 * @param nanosTimeout max wait time
1009 * @return {@code true} if acquired
1010 */
1011 private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
1012 throws InterruptedException {
1013
1014 long lastTime = System.nanoTime();
1015 final Node node = addWaiter(Node.SHARED);
1016 boolean failed = true;
1017 try {
1018 for (;;) {
1019 final Node p = node.predecessor();
1020 if (p == head) {
1021 int r = tryAcquireShared(arg);
1022 if (r >= 0) {
1023 setHeadAndPropagate(node, r);
1024 p.next = null; // help GC
1025 failed = false;
1026 return true;
1027 }
1028 }
1029 if (nanosTimeout <= 0)
1030 return false;
1031 if (shouldParkAfterFailedAcquire(p, node) &&
1032 nanosTimeout > spinForTimeoutThreshold)
1033 LockSupport.parkNanos(this, nanosTimeout);
1034 long now = System.nanoTime();
1035 nanosTimeout -= now - lastTime;
1036 lastTime = now;
1037 if (Thread.interrupted())
1038 throw new InterruptedException();
1039 }
1040 } finally {
1041 if (failed)
1042 cancelAcquire(node);
1043 }
1044 }
1045
1046 // Main exported methods
1047
1048 /**
1049 * Attempts to acquire in exclusive mode. This method should query
1050 * if the state of the object permits it to be acquired in the
1051 * exclusive mode, and if so to acquire it.
1052 *
1053 * <p>This method is always invoked by the thread performing
1054 * acquire. If this method reports failure, the acquire method
1055 * may queue the thread, if it is not already queued, until it is
1056 * signalled by a release from some other thread. This can be used
1057 * to implement method {@link Lock#tryLock()}.
1058 *
1059 * <p>The default
1060 * implementation throws {@link UnsupportedOperationException}.
1061 *
1062 * @param arg the acquire argument. This value is always the one
1063 * passed to an acquire method, or is the value saved on entry
1064 * to a condition wait. The value is otherwise uninterpreted
1065 * and can represent anything you like.
1066 * @return {@code true} if successful. Upon success, this object has
1067 * been acquired.
1068 * @throws IllegalMonitorStateException if acquiring would place this
1069 * synchronizer in an illegal state. This exception must be
1070 * thrown in a consistent fashion for synchronization to work
1071 * correctly.
1072 * @throws UnsupportedOperationException if exclusive mode is not supported
1073 */
1074 protected boolean tryAcquire(int arg) {
1075 throw new UnsupportedOperationException();
1076 }
1077
1078 /**
1079 * Attempts to set the state to reflect a release in exclusive
1080 * mode.
1081 *
1082 * <p>This method is always invoked by the thread performing release.
1083 *
1084 * <p>The default implementation throws
1085 * {@link UnsupportedOperationException}.
1086 *
1087 * @param arg the release argument. This value is always the one
1088 * passed to a release method, or the current state value upon
1089 * entry to a condition wait. The value is otherwise
1090 * uninterpreted and can represent anything you like.
1091 * @return {@code true} if this object is now in a fully released
1092 * state, so that any waiting threads may attempt to acquire;
1093 * and {@code false} otherwise.
1094 * @throws IllegalMonitorStateException if releasing would place this
1095 * synchronizer in an illegal state. This exception must be
1096 * thrown in a consistent fashion for synchronization to work
1097 * correctly.
1098 * @throws UnsupportedOperationException if exclusive mode is not supported
1099 */
1100 protected boolean tryRelease(int arg) {
1101 throw new UnsupportedOperationException();
1102 }
1103
1104 /**
1105 * Attempts to acquire in shared mode. This method should query if
1106 * the state of the object permits it to be acquired in the shared
1107 * mode, and if so to acquire it.
1108 *
1109 * <p>This method is always invoked by the thread performing
1110 * acquire. If this method reports failure, the acquire method
1111 * may queue the thread, if it is not already queued, until it is
1112 * signalled by a release from some other thread.
1113 *
1114 * <p>The default implementation throws {@link
1115 * UnsupportedOperationException}.
1116 *
1117 * @param arg the acquire argument. This value is always the one
1118 * passed to an acquire method, or is the value saved on entry
1119 * to a condition wait. The value is otherwise uninterpreted
1120 * and can represent anything you like.
1121 * @return a negative value on failure; zero if acquisition in shared
1122 * mode succeeded but no subsequent shared-mode acquire can
1123 * succeed; and a positive value if acquisition in shared
1124 * mode succeeded and subsequent shared-mode acquires might
1125 * also succeed, in which case a subsequent waiting thread
1126 * must check availability. (Support for three different
1127 * return values enables this method to be used in contexts
1128 * where acquires only sometimes act exclusively.) Upon
1129 * success, this object has been acquired.
1130 * @throws IllegalMonitorStateException if acquiring would place this
1131 * synchronizer in an illegal state. This exception must be
1132 * thrown in a consistent fashion for synchronization to work
1133 * correctly.
1134 * @throws UnsupportedOperationException if shared mode is not supported
1135 */
1136 protected int tryAcquireShared(int arg) {
1137 throw new UnsupportedOperationException();
1138 }
1139
1140 /**
1141 * Attempts to set the state to reflect a release in shared mode.
1142 *
1143 * <p>This method is always invoked by the thread performing release.
1144 *
1145 * <p>The default implementation throws
1146 * {@link UnsupportedOperationException}.
1147 *
1148 * @param arg the release argument. This value is always the one
1149 * passed to a release method, or the current state value upon
1150 * entry to a condition wait. The value is otherwise
1151 * uninterpreted and can represent anything you like.
1152 * @return {@code true} if this release of shared mode may permit a
1153 * waiting acquire (shared or exclusive) to succeed; and
1154 * {@code false} otherwise
1155 * @throws IllegalMonitorStateException if releasing would place this
1156 * synchronizer in an illegal state. This exception must be
1157 * thrown in a consistent fashion for synchronization to work
1158 * correctly.
1159 * @throws UnsupportedOperationException if shared mode is not supported
1160 */
1161 protected boolean tryReleaseShared(int arg) {
1162 throw new UnsupportedOperationException();
1163 }
1164
1165 /**
1166 * Returns {@code true} if synchronization is held exclusively with
1167 * respect to the current (calling) thread. This method is invoked
1168 * upon each call to a non-waiting {@link ConditionObject} method.
1169 * (Waiting methods instead invoke {@link #release}.)
1170 *
1171 * <p>The default implementation throws {@link
1172 * UnsupportedOperationException}. This method is invoked
1173 * internally only within {@link ConditionObject} methods, so need
1174 * not be defined if conditions are not used.
1175 *
1176 * @return {@code true} if synchronization is held exclusively;
1177 * {@code false} otherwise
1178 * @throws UnsupportedOperationException if conditions are not supported
1179 */
1180 protected boolean isHeldExclusively() {
1181 throw new UnsupportedOperationException();
1182 }
1183
1184 /**
1185 * Acquires in exclusive mode, ignoring interrupts. Implemented
1186 * by invoking at least once {@link #tryAcquire},
1187 * returning on success. Otherwise the thread is queued, possibly
1188 * repeatedly blocking and unblocking, invoking {@link
1189 * #tryAcquire} until success. This method can be used
1190 * to implement method {@link Lock#lock}.
1191 *
1192 * @param arg the acquire argument. This value is conveyed to
1193 * {@link #tryAcquire} but is otherwise uninterpreted and
1194 * can represent anything you like.
1195 */
1196 public final void acquire(int arg) {
1197 if (!tryAcquire(arg) &&
1198 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
1199 selfInterrupt();
1200 }
1201
1202 /**
1203 * Acquires in exclusive mode, aborting if interrupted.
1204 * Implemented by first checking interrupt status, then invoking
1205 * at least once {@link #tryAcquire}, returning on
1206 * success. Otherwise the thread is queued, possibly repeatedly
1207 * blocking and unblocking, invoking {@link #tryAcquire}
1208 * until success or the thread is interrupted. This method can be
1209 * used to implement method {@link Lock#lockInterruptibly}.
1210 *
1211 * @param arg the acquire argument. This value is conveyed to
1212 * {@link #tryAcquire} but is otherwise uninterpreted and
1213 * can represent anything you like.
1214 * @throws InterruptedException if the current thread is interrupted
1215 */
1216 public final void acquireInterruptibly(int arg)
1217 throws InterruptedException {
1218 if (Thread.interrupted())
1219 throw new InterruptedException();
1220 if (!tryAcquire(arg))
1221 doAcquireInterruptibly(arg);
1222 }
1223
1224 /**
1225 * Attempts to acquire in exclusive mode, aborting if interrupted,
1226 * and failing if the given timeout elapses. Implemented by first
1227 * checking interrupt status, then invoking at least once {@link
1228 * #tryAcquire}, returning on success. Otherwise, the thread is
1229 * queued, possibly repeatedly blocking and unblocking, invoking
1230 * {@link #tryAcquire} until success or the thread is interrupted
1231 * or the timeout elapses. This method can be used to implement
1232 * method {@link Lock#tryLock(long, TimeUnit)}.
1233 *
1234 * @param arg the acquire argument. This value is conveyed to
1235 * {@link #tryAcquire} but is otherwise uninterpreted and
1236 * can represent anything you like.
1237 * @param nanosTimeout the maximum number of nanoseconds to wait
1238 * @return {@code true} if acquired; {@code false} if timed out
1239 * @throws InterruptedException if the current thread is interrupted
1240 */
1241 public final boolean tryAcquireNanos(int arg, long nanosTimeout)
1242 throws InterruptedException {
1243 if (Thread.interrupted())
1244 throw new InterruptedException();
1245 return tryAcquire(arg) ||
1246 doAcquireNanos(arg, nanosTimeout);
1247 }
1248
1249 /**
1250 * Releases in exclusive mode. Implemented by unblocking one or
1251 * more threads if {@link #tryRelease} returns true.
1252 * This method can be used to implement method {@link Lock#unlock}.
1253 *
1254 * @param arg the release argument. This value is conveyed to
1255 * {@link #tryRelease} but is otherwise uninterpreted and
1256 * can represent anything you like.
1257 * @return the value returned from {@link #tryRelease}
1258 */
1259 public final boolean release(int arg) {
1260 if (tryRelease(arg)) {
1261 Node h = head;
1262 if (h != null && h.waitStatus != 0)
1263 unparkSuccessor(h);
1264 return true;
1265 }
1266 return false;
1267 }
1268
1269 /**
1270 * Acquires in shared mode, ignoring interrupts. Implemented by
1271 * first invoking at least once {@link #tryAcquireShared},
1272 * returning on success. Otherwise the thread is queued, possibly
1273 * repeatedly blocking and unblocking, invoking {@link
1274 * #tryAcquireShared} until success.
1275 *
1276 * @param arg the acquire argument. This value is conveyed to
1277 * {@link #tryAcquireShared} but is otherwise uninterpreted
1278 * and can represent anything you like.
1279 */
1280 public final void acquireShared(int arg) {
1281 if (tryAcquireShared(arg) < 0)
1282 doAcquireShared(arg);
1283 }
1284
1285 /**
1286 * Acquires in shared mode, aborting if interrupted. Implemented
1287 * by first checking interrupt status, then invoking at least once
1288 * {@link #tryAcquireShared}, returning on success. Otherwise the
1289 * thread is queued, possibly repeatedly blocking and unblocking,
1290 * invoking {@link #tryAcquireShared} until success or the thread
1291 * is interrupted.
1292 * @param arg the acquire argument
1293 * This value is conveyed to {@link #tryAcquireShared} but is
1294 * otherwise uninterpreted and can represent anything
1295 * you like.
1296 * @throws InterruptedException if the current thread is interrupted
1297 */
1298 public final void acquireSharedInterruptibly(int arg)
1299 throws InterruptedException {
1300 if (Thread.interrupted())
1301 throw new InterruptedException();
1302 if (tryAcquireShared(arg) < 0)
1303 doAcquireSharedInterruptibly(arg);
1304 }
1305
1306 /**
1307 * Attempts to acquire in shared mode, aborting if interrupted, and
1308 * failing if the given timeout elapses. Implemented by first
1309 * checking interrupt status, then invoking at least once {@link
1310 * #tryAcquireShared}, returning on success. Otherwise, the
1311 * thread is queued, possibly repeatedly blocking and unblocking,
1312 * invoking {@link #tryAcquireShared} until success or the thread
1313 * is interrupted or the timeout elapses.
1314 *
1315 * @param arg the acquire argument. This value is conveyed to
1316 * {@link #tryAcquireShared} but is otherwise uninterpreted
1317 * and can represent anything you like.
1318 * @param nanosTimeout the maximum number of nanoseconds to wait
1319 * @return {@code true} if acquired; {@code false} if timed out
1320 * @throws InterruptedException if the current thread is interrupted
1321 */
1322 public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
1323 throws InterruptedException {
1324 if (Thread.interrupted())
1325 throw new InterruptedException();
1326 return tryAcquireShared(arg) >= 0 ||
1327 doAcquireSharedNanos(arg, nanosTimeout);
1328 }
1329
1330 /**
1331 * Releases in shared mode. Implemented by unblocking one or more
1332 * threads if {@link #tryReleaseShared} returns true.
1333 *
1334 * @param arg the release argument. This value is conveyed to
1335 * {@link #tryReleaseShared} but is otherwise uninterpreted
1336 * and can represent anything you like.
1337 * @return the value returned from {@link #tryReleaseShared}
1338 */
1339 public final boolean releaseShared(int arg) {
1340 if (tryReleaseShared(arg)) {
1341 doReleaseShared();
1342 return true;
1343 }
1344 return false;
1345 }
1346
1347 // Queue inspection methods
1348
1349 /**
1350 * Queries whether any threads are waiting to acquire. Note that
1351 * because cancellations due to interrupts and timeouts may occur
1352 * at any time, a {@code true} return does not guarantee that any
1353 * other thread will ever acquire.
1354 *
1355 * <p>In this implementation, this operation returns in
1356 * constant time.
1357 *
1358 * @return {@code true} if there may be other threads waiting to acquire
1359 */
1360 public final boolean hasQueuedThreads() {
1361 return head != tail;
1362 }
1363
1364 /**
1365 * Queries whether any threads have ever contended to acquire this
1366 * synchronizer; that is if an acquire method has ever blocked.
1367 *
1368 * <p>In this implementation, this operation returns in
1369 * constant time.
1370 *
1371 * @return {@code true} if there has ever been contention
1372 */
1373 public final boolean hasContended() {
1374 return head != null;
1375 }
1376
1377 /**
1378 * Returns the first (longest-waiting) thread in the queue, or
1379 * {@code null} if no threads are currently queued.
1380 *
1381 * <p>In this implementation, this operation normally returns in
1382 * constant time, but may iterate upon contention if other threads are
1383 * concurrently modifying the queue.
1384 *
1385 * @return the first (longest-waiting) thread in the queue, or
1386 * {@code null} if no threads are currently queued
1387 */
1388 public final Thread getFirstQueuedThread() {
1389 // handle only fast path, else relay
1390 return (head == tail) ? null : fullGetFirstQueuedThread();
1391 }
1392
1393 /**
1394 * Version of getFirstQueuedThread called when fastpath fails
1395 */
1396 private Thread fullGetFirstQueuedThread() {
1397 /*
1398 * The first node is normally head.next. Try to get its
1399 * thread field, ensuring consistent reads: If thread
1400 * field is nulled out or s.prev is no longer head, then
1401 * some other thread(s) concurrently performed setHead in
1402 * between some of our reads. We try this twice before
1403 * resorting to traversal.
1404 */
1405 Node h, s;
1406 Thread st;
1407 if (((h = head) != null && (s = h.next) != null &&
1408 s.prev == head && (st = s.thread) != null) ||
1409 ((h = head) != null && (s = h.next) != null &&
1410 s.prev == head && (st = s.thread) != null))
1411 return st;
1412
1413 /*
1414 * Head's next field might not have been set yet, or may have
1415 * been unset after setHead. So we must check to see if tail
1416 * is actually first node. If not, we continue on, safely
1417 * traversing from tail back to head to find first,
1418 * guaranteeing termination.
1419 */
1420
1421 Node t = tail;
1422 Thread firstThread = null;
1423 while (t != null && t != head) {
1424 Thread tt = t.thread;
1425 if (tt != null)
1426 firstThread = tt;
1427 t = t.prev;
1428 }
1429 return firstThread;
1430 }
1431
1432 /**
1433 * Returns true if the given thread is currently queued.
1434 *
1435 * <p>This implementation traverses the queue to determine
1436 * presence of the given thread.
1437 *
1438 * @param thread the thread
1439 * @return {@code true} if the given thread is on the queue
1440 * @throws NullPointerException if the thread is null
1441 */
1442 public final boolean isQueued(Thread thread) {
1443 if (thread == null)
1444 throw new NullPointerException();
1445 for (Node p = tail; p != null; p = p.prev)
1446 if (p.thread == thread)
1447 return true;
1448 return false;
1449 }
1450
1451 /**
1452 * Returns {@code true} if the apparent first queued thread, if one
1453 * exists, is waiting in exclusive mode. If this method returns
1454 * {@code true}, and the current thread is attempting to acquire in
1455 * shared mode (that is, this method is invoked from {@link
1456 * #tryAcquireShared}) then it is guaranteed that the current thread
1457 * is not the first queued thread. Used only as a heuristic in
1458 * ReentrantReadWriteLock.
1459 */
1460 final boolean apparentlyFirstQueuedIsExclusive() {
1461 Node h, s;
1462 return (h = head) != null &&
1463 (s = h.next) != null &&
1464 !s.isShared() &&
1465 s.thread != null;
1466 }
1467
1468 /**
1469 * Queries whether any threads have been waiting to acquire longer
1470 * than the current thread.
1471 *
1472 * <p>An invocation of this method is equivalent to (but may be
1473 * more efficient than):
1474 * <pre> {@code
1475 * getFirstQueuedThread() != Thread.currentThread() &&
1476 * hasQueuedThreads()}</pre>
1477 *
1478 * <p>Note that because cancellations due to interrupts and
1479 * timeouts may occur at any time, a {@code true} return does not
1480 * guarantee that some other thread will acquire before the current
1481 * thread. Likewise, it is possible for another thread to win a
1482 * race to enqueue after this method has returned {@code false},
1483 * due to the queue being empty.
1484 *
1485 * <p>This method is designed to be used by a fair synchronizer to
1486 * avoid <a href="AbstractQueuedSynchronizer#barging">barging</a>.
1487 * Such a synchronizer's {@link #tryAcquire} method should return
1488 * {@code false}, and its {@link #tryAcquireShared} method should
1489 * return a negative value, if this method returns {@code true}
1490 * (unless this is a reentrant acquire). For example, the {@code
1491 * tryAcquire} method for a fair, reentrant, exclusive mode
1492 * synchronizer might look like this:
1493 *
1494 * <pre> {@code
1495 * protected boolean tryAcquire(int arg) {
1496 * if (isHeldExclusively()) {
1497 * // A reentrant acquire; increment hold count
1498 * return true;
1499 * } else if (hasQueuedPredecessors()) {
1500 * return false;
1501 * } else {
1502 * // try to acquire normally
1503 * }
1504 * }}</pre>
1505 *
1506 * @return {@code true} if there is a queued thread preceding the
1507 * current thread, and {@code false} if the current thread
1508 * is at the head of the queue or the queue is empty
1509 * @since 1.7
1510 */
1511 public final boolean hasQueuedPredecessors() {
1512 // The correctness of this depends on head being initialized
1513 // before tail and on head.next being accurate if the current
1514 // thread is first in queue.
1515 Node t = tail; // Read fields in reverse initialization order
1516 Node h = head;
1517 Node s;
1518 return h != t &&
1519 ((s = h.next) == null || s.thread != Thread.currentThread());
1520 }
1521
1522
1523 // Instrumentation and monitoring methods
1524
1525 /**
1526 * Returns an estimate of the number of threads waiting to
1527 * acquire. The value is only an estimate because the number of
1528 * threads may change dynamically while this method traverses
1529 * internal data structures. This method is designed for use in
1530 * monitoring system state, not for synchronization
1531 * control.
1532 *
1533 * @return the estimated number of threads waiting to acquire
1534 */
1535 public final int getQueueLength() {
1536 int n = 0;
1537 for (Node p = tail; p != null; p = p.prev) {
1538 if (p.thread != null)
1539 ++n;
1540 }
1541 return n;
1542 }
1543
1544 /**
1545 * Returns a collection containing threads that may be waiting to
1546 * acquire. Because the actual set of threads may change
1547 * dynamically while constructing this result, the returned
1548 * collection is only a best-effort estimate. The elements of the
1549 * returned collection are in no particular order. This method is
1550 * designed to facilitate construction of subclasses that provide
1551 * more extensive monitoring facilities.
1552 *
1553 * @return the collection of threads
1554 */
1555 public final Collection<Thread> getQueuedThreads() {
1556 ArrayList<Thread> list = new ArrayList<Thread>();
1557 for (Node p = tail; p != null; p = p.prev) {
1558 Thread t = p.thread;
1559 if (t != null)
1560 list.add(t);
1561 }
1562 return list;
1563 }
1564
1565 /**
1566 * Returns a collection containing threads that may be waiting to
1567 * acquire in exclusive mode. This has the same properties
1568 * as {@link #getQueuedThreads} except that it only returns
1569 * those threads waiting due to an exclusive acquire.
1570 *
1571 * @return the collection of threads
1572 */
1573 public final Collection<Thread> getExclusiveQueuedThreads() {
1574 ArrayList<Thread> list = new ArrayList<Thread>();
1575 for (Node p = tail; p != null; p = p.prev) {
1576 if (!p.isShared()) {
1577 Thread t = p.thread;
1578 if (t != null)
1579 list.add(t);
1580 }
1581 }
1582 return list;
1583 }
1584
1585 /**
1586 * Returns a collection containing threads that may be waiting to
1587 * acquire in shared mode. This has the same properties
1588 * as {@link #getQueuedThreads} except that it only returns
1589 * those threads waiting due to a shared acquire.
1590 *
1591 * @return the collection of threads
1592 */
1593 public final Collection<Thread> getSharedQueuedThreads() {
1594 ArrayList<Thread> list = new ArrayList<Thread>();
1595 for (Node p = tail; p != null; p = p.prev) {
1596 if (p.isShared()) {
1597 Thread t = p.thread;
1598 if (t != null)
1599 list.add(t);
1600 }
1601 }
1602 return list;
1603 }
1604
1605 /**
1606 * Returns a string identifying this synchronizer, as well as its state.
1607 * The state, in brackets, includes the String {@code "State ="}
1608 * followed by the current value of {@link #getState}, and either
1609 * {@code "nonempty"} or {@code "empty"} depending on whether the
1610 * queue is empty.
1611 *
1612 * @return a string identifying this synchronizer, as well as its state
1613 */
1614 public String toString() {
1615 int s = getState();
1616 String q = hasQueuedThreads() ? "non" : "";
1617 return super.toString() +
1618 "[State = " + s + ", " + q + "empty queue]";
1619 }
1620
1621
1622 // Internal support methods for Conditions
1623
1624 /**
1625 * Returns true if a node, always one that was initially placed on
1626 * a condition queue, is now waiting to reacquire on sync queue.
1627 * @param node the node
1628 * @return true if is reacquiring
1629 */
1630 final boolean isOnSyncQueue(Node node) {
1631 if (node.waitStatus == Node.CONDITION || node.prev == null)
1632 return false;
1633 if (node.next != null) // If has successor, it must be on queue
1634 return true;
1635 /*
1636 * node.prev can be non-null, but not yet on queue because
1637 * the CAS to place it on queue can fail. So we have to
1638 * traverse from tail to make sure it actually made it. It
1639 * will always be near the tail in calls to this method, and
1640 * unless the CAS failed (which is unlikely), it will be
1641 * there, so we hardly ever traverse much.
1642 */
1643 return findNodeFromTail(node);
1644 }
1645
1646 /**
1647 * Returns true if node is on sync queue by searching backwards from tail.
1648 * Called only when needed by isOnSyncQueue.
1649 * @return true if present
1650 */
1651 private boolean findNodeFromTail(Node node) {
1652 Node t = tail;
1653 for (;;) {
1654 if (t == node)
1655 return true;
1656 if (t == null)
1657 return false;
1658 t = t.prev;
1659 }
1660 }
1661
1662 /**
1663 * Transfers a node from a condition queue onto sync queue.
1664 * Returns true if successful.
1665 * @param node the node
1666 * @return true if successfully transferred (else the node was
1667 * cancelled before signal).
1668 */
1669 final boolean transferForSignal(Node node) {
1670 /*
1671 * If cannot change waitStatus, the node has been cancelled.
1672 */
1673 if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
1674 return false;
1675
1676 /*
1677 * Splice onto queue and try to set waitStatus of predecessor to
1678 * indicate that thread is (probably) waiting. If cancelled or
1679 * attempt to set waitStatus fails, wake up to resync (in which
1680 * case the waitStatus can be transiently and harmlessly wrong).
1681 */
1682 Node p = enq(node);
1683 int ws = p.waitStatus;
1684 if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
1685 LockSupport.unpark(node.thread);
1686 return true;
1687 }
1688
1689 /**
1690 * Transfers node, if necessary, to sync queue after a cancelled
1691 * wait. Returns true if thread was cancelled before being
1692 * signalled.
1693 * @param current the waiting thread
1694 * @param node its node
1695 * @return true if cancelled before the node was signalled
1696 */
1697 final boolean transferAfterCancelledWait(Node node) {
1698 if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
1699 enq(node);
1700 return true;
1701 }
1702 /*
1703 * If we lost out to a signal(), then we can't proceed
1704 * until it finishes its enq(). Cancelling during an
1705 * incomplete transfer is both rare and transient, so just
1706 * spin.
1707 */
1708 while (!isOnSyncQueue(node))
1709 Thread.yield();
1710 return false;
1711 }
1712
1713 /**
1714 * Invokes release with current state value; returns saved state.
1715 * Cancels node and throws exception on failure.
1716 * @param node the condition node for this wait
1717 * @return previous sync state
1718 */
1719 final int fullyRelease(Node node) {
1720 boolean failed = true;
1721 try {
1722 int savedState = getState();
1723 if (release(savedState)) {
1724 failed = false;
1725 return savedState;
1726 } else {
1727 throw new IllegalMonitorStateException();
1728 }
1729 } finally {
1730 if (failed)
1731 node.waitStatus = Node.CANCELLED;
1732 }
1733 }
1734
1735 // Instrumentation methods for conditions
1736
1737 /**
1738 * Queries whether the given ConditionObject
1739 * uses this synchronizer as its lock.
1740 *
1741 * @param condition the condition
1742 * @return <tt>true</tt> if owned
1743 * @throws NullPointerException if the condition is null
1744 */
1745 public final boolean owns(ConditionObject condition) {
1746 if (condition == null)
1747 throw new NullPointerException();
1748 return condition.isOwnedBy(this);
1749 }
1750
1751 /**
1752 * Queries whether any threads are waiting on the given condition
1753 * associated with this synchronizer. Note that because timeouts
1754 * and interrupts may occur at any time, a <tt>true</tt> return
1755 * does not guarantee that a future <tt>signal</tt> will awaken
1756 * any threads. This method is designed primarily for use in
1757 * monitoring of the system state.
1758 *
1759 * @param condition the condition
1760 * @return <tt>true</tt> if there are any waiting threads
1761 * @throws IllegalMonitorStateException if exclusive synchronization
1762 * is not held
1763 * @throws IllegalArgumentException if the given condition is
1764 * not associated with this synchronizer
1765 * @throws NullPointerException if the condition is null
1766 */
1767 public final boolean hasWaiters(ConditionObject condition) {
1768 if (!owns(condition))
1769 throw new IllegalArgumentException("Not owner");
1770 return condition.hasWaiters();
1771 }
1772
1773 /**
1774 * Returns an estimate of the number of threads waiting on the
1775 * given condition associated with this synchronizer. Note that
1776 * because timeouts and interrupts may occur at any time, the
1777 * estimate serves only as an upper bound on the actual number of
1778 * waiters. This method is designed for use in monitoring of the
1779 * system state, not for synchronization control.
1780 *
1781 * @param condition the condition
1782 * @return the estimated number of waiting threads
1783 * @throws IllegalMonitorStateException if exclusive synchronization
1784 * is not held
1785 * @throws IllegalArgumentException if the given condition is
1786 * not associated with this synchronizer
1787 * @throws NullPointerException if the condition is null
1788 */
1789 public final int getWaitQueueLength(ConditionObject condition) {
1790 if (!owns(condition))
1791 throw new IllegalArgumentException("Not owner");
1792 return condition.getWaitQueueLength();
1793 }
1794
1795 /**
1796 * Returns a collection containing those threads that may be
1797 * waiting on the given condition associated with this
1798 * synchronizer. Because the actual set of threads may change
1799 * dynamically while constructing this result, the returned
1800 * collection is only a best-effort estimate. The elements of the
1801 * returned collection are in no particular order.
1802 *
1803 * @param condition the condition
1804 * @return the collection of threads
1805 * @throws IllegalMonitorStateException if exclusive synchronization
1806 * is not held
1807 * @throws IllegalArgumentException if the given condition is
1808 * not associated with this synchronizer
1809 * @throws NullPointerException if the condition is null
1810 */
1811 public final Collection<Thread> getWaitingThreads(ConditionObject condition) {
1812 if (!owns(condition))
1813 throw new IllegalArgumentException("Not owner");
1814 return condition.getWaitingThreads();
1815 }
1816
1817 /**
1818 * Condition implementation for a {@link
1819 * AbstractQueuedSynchronizer} serving as the basis of a {@link
1820 * Lock} implementation.
1821 *
1822 * <p>Method documentation for this class describes mechanics,
1823 * not behavioral specifications from the point of view of Lock
1824 * and Condition users. Exported versions of this class will in
1825 * general need to be accompanied by documentation describing
1826 * condition semantics that rely on those of the associated
1827 * <tt>AbstractQueuedSynchronizer</tt>.
1828 *
1829 * <p>This class is Serializable, but all fields are transient,
1830 * so deserialized conditions have no waiters.
1831 */
1832 public class ConditionObject implements Condition, java.io.Serializable {
1833 private static final long serialVersionUID = 1173984872572414699L;
1834 /** First node of condition queue. */
1835 private transient Node firstWaiter;
1836 /** Last node of condition queue. */
1837 private transient Node lastWaiter;
1838
1839 /**
1840 * Creates a new <tt>ConditionObject</tt> instance.
1841 */
1842 public ConditionObject() { }
1843
1844 // Internal methods
1845
1846 /**
1847 * Adds a new waiter to wait queue.
1848 * @return its new wait node
1849 */
1850 private Node addConditionWaiter() {
1851 Node t = lastWaiter;
1852 // If lastWaiter is cancelled, clean out.
1853 if (t != null && t.waitStatus != Node.CONDITION) {
1854 unlinkCancelledWaiters();
1855 t = lastWaiter;
1856 }
1857 Node node = new Node(Thread.currentThread(), Node.CONDITION);
1858 if (t == null)
1859 firstWaiter = node;
1860 else
1861 t.nextWaiter = node;
1862 lastWaiter = node;
1863 return node;
1864 }
1865
1866 /**
1867 * Removes and transfers nodes until hit non-cancelled one or
1868 * null. Split out from signal in part to encourage compilers
1869 * to inline the case of no waiters.
1870 * @param first (non-null) the first node on condition queue
1871 */
1872 private void doSignal(Node first) {
1873 do {
1874 if ( (firstWaiter = first.nextWaiter) == null)
1875 lastWaiter = null;
1876 first.nextWaiter = null;
1877 } while (!transferForSignal(first) &&
1878 (first = firstWaiter) != null);
1879 }
1880
1881 /**
1882 * Removes and transfers all nodes.
1883 * @param first (non-null) the first node on condition queue
1884 */
1885 private void doSignalAll(Node first) {
1886 lastWaiter = firstWaiter = null;
1887 do {
1888 Node next = first.nextWaiter;
1889 first.nextWaiter = null;
1890 transferForSignal(first);
1891 first = next;
1892 } while (first != null);
1893 }
1894
1895 /**
1896 * Unlinks cancelled waiter nodes from condition queue.
1897 * Called only while holding lock. This is called when
1898 * cancellation occurred during condition wait, and upon
1899 * insertion of a new waiter when lastWaiter is seen to have
1900 * been cancelled. This method is needed to avoid garbage
1901 * retention in the absence of signals. So even though it may
1902 * require a full traversal, it comes into play only when
1903 * timeouts or cancellations occur in the absence of
1904 * signals. It traverses all nodes rather than stopping at a
1905 * particular target to unlink all pointers to garbage nodes
1906 * without requiring many re-traversals during cancellation
1907 * storms.
1908 */
1909 private void unlinkCancelledWaiters() {
1910 Node t = firstWaiter;
1911 Node trail = null;
1912 while (t != null) {
1913 Node next = t.nextWaiter;
1914 if (t.waitStatus != Node.CONDITION) {
1915 t.nextWaiter = null;
1916 if (trail == null)
1917 firstWaiter = next;
1918 else
1919 trail.nextWaiter = next;
1920 if (next == null)
1921 lastWaiter = trail;
1922 }
1923 else
1924 trail = t;
1925 t = next;
1926 }
1927 }
1928
1929 // public methods
1930
1931 /**
1932 * Moves the longest-waiting thread, if one exists, from the
1933 * wait queue for this condition to the wait queue for the
1934 * owning lock.
1935 *
1936 * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
1937 * returns {@code false}
1938 */
1939 public final void signal() {
1940 if (!isHeldExclusively())
1941 throw new IllegalMonitorStateException();
1942 Node first = firstWaiter;
1943 if (first != null)
1944 doSignal(first);
1945 }
1946
1947 /**
1948 * Moves all threads from the wait queue for this condition to
1949 * the wait queue for the owning lock.
1950 *
1951 * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
1952 * returns {@code false}
1953 */
1954 public final void signalAll() {
1955 if (!isHeldExclusively())
1956 throw new IllegalMonitorStateException();
1957 Node first = firstWaiter;
1958 if (first != null)
1959 doSignalAll(first);
1960 }
1961
1962 /**
1963 * Implements uninterruptible condition wait.
1964 * <ol>
1965 * <li> Save lock state returned by {@link #getState}.
1966 * <li> Invoke {@link #release} with
1967 * saved state as argument, throwing
1968 * IllegalMonitorStateException if it fails.
1969 * <li> Block until signalled.
1970 * <li> Reacquire by invoking specialized version of
1971 * {@link #acquire} with saved state as argument.
1972 * </ol>
1973 */
1974 public final void awaitUninterruptibly() {
1975 Node node = addConditionWaiter();
1976 int savedState = fullyRelease(node);
1977 boolean interrupted = false;
1978 while (!isOnSyncQueue(node)) {
1979 LockSupport.park(this);
1980 if (Thread.interrupted())
1981 interrupted = true;
1982 }
1983 if (acquireQueued(node, savedState) || interrupted)
1984 selfInterrupt();
1985 }
1986
1987 /*
1988 * For interruptible waits, we need to track whether to throw
1989 * InterruptedException, if interrupted while blocked on
1990 * condition, versus reinterrupt current thread, if
1991 * interrupted while blocked waiting to re-acquire.
1992 */
1993
1994 /** Mode meaning to reinterrupt on exit from wait */
1995 private static final int REINTERRUPT = 1;
1996 /** Mode meaning to throw InterruptedException on exit from wait */
1997 private static final int THROW_IE = -1;
1998
1999 /**
2000 * Checks for interrupt, returning THROW_IE if interrupted
2001 * before signalled, REINTERRUPT if after signalled, or
2002 * 0 if not interrupted.
2003 */
2004 private int checkInterruptWhileWaiting(Node node) {
2005 return Thread.interrupted() ?
2006 (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
2007 0;
2008 }
2009
2010 /**
2011 * Throws InterruptedException, reinterrupts current thread, or
2012 * does nothing, depending on mode.
2013 */
2014 private void reportInterruptAfterWait(int interruptMode)
2015 throws InterruptedException {
2016 if (interruptMode == THROW_IE)
2017 throw new InterruptedException();
2018 else if (interruptMode == REINTERRUPT)
2019 selfInterrupt();
2020 }
2021
2022 /**
2023 * Implements interruptible condition wait.
2024 * <ol>
2025 * <li> If current thread is interrupted, throw InterruptedException.
2026 * <li> Save lock state returned by {@link #getState}.
2027 * <li> Invoke {@link #release} with
2028 * saved state as argument, throwing
2029 * IllegalMonitorStateException if it fails.
2030 * <li> Block until signalled or interrupted.
2031 * <li> Reacquire by invoking specialized version of
2032 * {@link #acquire} with saved state as argument.
2033 * <li> If interrupted while blocked in step 4, throw InterruptedException.
2034 * </ol>
2035 */
2036 public final void await() throws InterruptedException {
2037 if (Thread.interrupted())
2038 throw new InterruptedException();
2039 Node node = addConditionWaiter();
2040 int savedState = fullyRelease(node);
2041 int interruptMode = 0;
2042 while (!isOnSyncQueue(node)) {
2043 LockSupport.park(this);
2044 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
2045 break;
2046 }
2047 if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
2048 interruptMode = REINTERRUPT;
2049 if (node.nextWaiter != null) // clean up if cancelled
2050 unlinkCancelledWaiters();
2051 if (interruptMode != 0)
2052 reportInterruptAfterWait(interruptMode);
2053 }
2054
2055 /**
2056 * Implements timed condition wait.
2057 * <ol>
2058 * <li> If current thread is interrupted, throw InterruptedException.
2059 * <li> Save lock state returned by {@link #getState}.
2060 * <li> Invoke {@link #release} with
2061 * saved state as argument, throwing
2062 * IllegalMonitorStateException if it fails.
2063 * <li> Block until signalled, interrupted, or timed out.
2064 * <li> Reacquire by invoking specialized version of
2065 * {@link #acquire} with saved state as argument.
2066 * <li> If interrupted while blocked in step 4, throw InterruptedException.
2067 * </ol>
2068 */
2069 public final long awaitNanos(long nanosTimeout)
2070 throws InterruptedException {
2071 if (Thread.interrupted())
2072 throw new InterruptedException();
2073 Node node = addConditionWaiter();
2074 int savedState = fullyRelease(node);
2075 long lastTime = System.nanoTime();
2076 int interruptMode = 0;
2077 while (!isOnSyncQueue(node)) {
2078 if (nanosTimeout <= 0L) {
2079 transferAfterCancelledWait(node);
2080 break;
2081 }
2082 LockSupport.parkNanos(this, nanosTimeout);
2083 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
2084 break;
2085
2086 long now = System.nanoTime();
2087 nanosTimeout -= now - lastTime;
2088 lastTime = now;
2089 }
2090 if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
2091 interruptMode = REINTERRUPT;
2092 if (node.nextWaiter != null)
2093 unlinkCancelledWaiters();
2094 if (interruptMode != 0)
2095 reportInterruptAfterWait(interruptMode);
2096 return nanosTimeout - (System.nanoTime() - lastTime);
2097 }
2098
2099 /**
2100 * Implements absolute timed condition wait.
2101 * <ol>
2102 * <li> If current thread is interrupted, throw InterruptedException.
2103 * <li> Save lock state returned by {@link #getState}.
2104 * <li> Invoke {@link #release} with
2105 * saved state as argument, throwing
2106 * IllegalMonitorStateException if it fails.
2107 * <li> Block until signalled, interrupted, or timed out.
2108 * <li> Reacquire by invoking specialized version of
2109 * {@link #acquire} with saved state as argument.
2110 * <li> If interrupted while blocked in step 4, throw InterruptedException.
2111 * <li> If timed out while blocked in step 4, return false, else true.
2112 * </ol>
2113 */
2114 public final boolean awaitUntil(Date deadline)
2115 throws InterruptedException {
2116 if (deadline == null)
2117 throw new NullPointerException();
2118 long abstime = deadline.getTime();
2119 if (Thread.interrupted())
2120 throw new InterruptedException();
2121 Node node = addConditionWaiter();
2122 int savedState = fullyRelease(node);
2123 boolean timedout = false;
2124 int interruptMode = 0;
2125 while (!isOnSyncQueue(node)) {
2126 if (System.currentTimeMillis() > abstime) {
2127 timedout = transferAfterCancelledWait(node);
2128 break;
2129 }
2130 LockSupport.parkUntil(this, abstime);
2131 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
2132 break;
2133 }
2134 if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
2135 interruptMode = REINTERRUPT;
2136 if (node.nextWaiter != null)
2137 unlinkCancelledWaiters();
2138 if (interruptMode != 0)
2139 reportInterruptAfterWait(interruptMode);
2140 return !timedout;
2141 }
2142
2143 /**
2144 * Implements timed condition wait.
2145 * <ol>
2146 * <li> If current thread is interrupted, throw InterruptedException.
2147 * <li> Save lock state returned by {@link #getState}.
2148 * <li> Invoke {@link #release} with
2149 * saved state as argument, throwing
2150 * IllegalMonitorStateException if it fails.
2151 * <li> Block until signalled, interrupted, or timed out.
2152 * <li> Reacquire by invoking specialized version of
2153 * {@link #acquire} with saved state as argument.
2154 * <li> If interrupted while blocked in step 4, throw InterruptedException.
2155 * <li> If timed out while blocked in step 4, return false, else true.
2156 * </ol>
2157 */
2158 public final boolean await(long time, TimeUnit unit)
2159 throws InterruptedException {
2160 if (unit == null)
2161 throw new NullPointerException();
2162 long nanosTimeout = unit.toNanos(time);
2163 if (Thread.interrupted())
2164 throw new InterruptedException();
2165 Node node = addConditionWaiter();
2166 int savedState = fullyRelease(node);
2167 long lastTime = System.nanoTime();
2168 boolean timedout = false;
2169 int interruptMode = 0;
2170 while (!isOnSyncQueue(node)) {
2171 if (nanosTimeout <= 0L) {
2172 timedout = transferAfterCancelledWait(node);
2173 break;
2174 }
2175 if (nanosTimeout >= spinForTimeoutThreshold)
2176 LockSupport.parkNanos(this, nanosTimeout);
2177 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
2178 break;
2179 long now = System.nanoTime();
2180 nanosTimeout -= now - lastTime;
2181 lastTime = now;
2182 }
2183 if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
2184 interruptMode = REINTERRUPT;
2185 if (node.nextWaiter != null)
2186 unlinkCancelledWaiters();
2187 if (interruptMode != 0)
2188 reportInterruptAfterWait(interruptMode);
2189 return !timedout;
2190 }
2191
2192 // support for instrumentation
2193
2194 /**
2195 * Returns true if this condition was created by the given
2196 * synchronization object.
2197 *
2198 * @return {@code true} if owned
2199 */
2200 final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {
2201 return sync == AbstractQueuedSynchronizer.this;
2202 }
2203
2204 /**
2205 * Queries whether any threads are waiting on this condition.
2206 * Implements {@link AbstractQueuedSynchronizer#hasWaiters}.
2207 *
2208 * @return {@code true} if there are any waiting threads
2209 * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
2210 * returns {@code false}
2211 */
2212 protected final boolean hasWaiters() {
2213 if (!isHeldExclusively())
2214 throw new IllegalMonitorStateException();
2215 for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
2216 if (w.waitStatus == Node.CONDITION)
2217 return true;
2218 }
2219 return false;
2220 }
2221
2222 /**
2223 * Returns an estimate of the number of threads waiting on
2224 * this condition.
2225 * Implements {@link AbstractQueuedSynchronizer#getWaitQueueLength}.
2226 *
2227 * @return the estimated number of waiting threads
2228 * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
2229 * returns {@code false}
2230 */
2231 protected final int getWaitQueueLength() {
2232 if (!isHeldExclusively())
2233 throw new IllegalMonitorStateException();
2234 int n = 0;
2235 for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
2236 if (w.waitStatus == Node.CONDITION)
2237 ++n;
2238 }
2239 return n;
2240 }
2241
2242 /**
2243 * Returns a collection containing those threads that may be
2244 * waiting on this Condition.
2245 * Implements {@link AbstractQueuedSynchronizer#getWaitingThreads}.
2246 *
2247 * @return the collection of threads
2248 * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
2249 * returns {@code false}
2250 */
2251 protected final Collection<Thread> getWaitingThreads() {
2252 if (!isHeldExclusively())
2253 throw new IllegalMonitorStateException();
2254 ArrayList<Thread> list = new ArrayList<Thread>();
2255 for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
2256 if (w.waitStatus == Node.CONDITION) {
2257 Thread t = w.thread;
2258 if (t != null)
2259 list.add(t);
2260 }
2261 }
2262 return list;
2263 }
2264 }
2265
2266 /**
2267 * Setup to support compareAndSet. We need to natively implement
2268 * this here: For the sake of permitting future enhancements, we
2269 * cannot explicitly subclass AtomicInteger, which would be
2270 * efficient and useful otherwise. So, as the lesser of evils, we
2271 * natively implement using hotspot intrinsics API. And while we
2272 * are at it, we do the same for other CASable fields (which could
2273 * otherwise be done with atomic field updaters).
2274 */
2275 private static final Unsafe unsafe = Unsafe.getUnsafe();
2276 private static final long stateOffset;
2277 private static final long headOffset;
2278 private static final long tailOffset;
2279 private static final long waitStatusOffset;
2280 private static final long nextOffset;
2281
2282 static {
2283 try {
2284 stateOffset = unsafe.objectFieldOffset
2285 (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
2286 headOffset = unsafe.objectFieldOffset
2287 (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
2288 tailOffset = unsafe.objectFieldOffset
2289 (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
2290 waitStatusOffset = unsafe.objectFieldOffset
2291 (Node.class.getDeclaredField("waitStatus"));
2292 nextOffset = unsafe.objectFieldOffset
2293 (Node.class.getDeclaredField("next"));
2294
2295 } catch (Exception ex) { throw new Error(ex); }
2296 }
2297
2298 /**
2299 * CAS head field. Used only by enq.
2300 */
2301 private final boolean compareAndSetHead(Node update) {
2302 return unsafe.compareAndSwapObject(this, headOffset, null, update);
2303 }
2304
2305 /**
2306 * CAS tail field. Used only by enq.
2307 */
2308 private final boolean compareAndSetTail(Node expect, Node update) {
2309 return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
2310 }
2311
2312 /**
2313 * CAS waitStatus field of a node.
2314 */
2315 private static final boolean compareAndSetWaitStatus(Node node,
2316 int expect,
2317 int update) {
2318 return unsafe.compareAndSwapInt(node, waitStatusOffset,
2319 expect, update);
2320 }
2321
2322 /**
2323 * CAS next field of a node.
2324 */
2325 private static final boolean compareAndSetNext(Node node,
2326 Node expect,
2327 Node update) {
2328 return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
2329 }
2330 }
其中，共享锁源码相关的代码如下：
public static class ReadLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = -5992448646407690164L;
// ReentrantReadWriteLock的AQS对象
private final Sync sync;
protected ReadLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
// 获取“共享锁”
public void lock() {
sync.acquireShared(1);
}
// 如果线程是中断状态，则抛出一场，否则尝试获取共享锁。
public void lockInterruptibly() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
// 尝试获取“共享锁”
public boolean tryLock() {
return sync.tryReadLock();
}
// 在指定时间内，尝试获取“共享锁”
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
// 释放“共享锁”
public void unlock() {
sync.releaseShared(1);
}
// 新建条件
public Condition newCondition() {
throw new UnsupportedOperationException();
}
public String toString() {
int r = sync.getReadLockCount();
return super.toString() +
"[Read locks = " + r + "]";
}
}
说明：
ReadLock中的sync是一个Sync对象，Sync继承于AQS类，即Sync就是一个锁。ReentrantReadWriteLock中也有一个Sync对象，而且ReadLock中的sync和ReentrantReadWriteLock中的sync是对应关系。即ReentrantReadWriteLock和ReadLock共享同一个AQS对象，共享同一把锁。
ReentrantReadWriteLock中Sync的定义如下：
final Sync sync;
下面，分别从“获取共享锁”和“释放共享锁”两个方面对共享锁进行说明。
获取共享锁
获取共享锁的思想(即lock函数的步骤)，是先通过tryAcquireShared()尝试获取共享锁。尝试成功的话，则直接返回；尝试失败的话，则通过doAcquireShared()不断的循环并尝试获取锁，若有需要，则阻塞等待。doAcquireShared()在循环中每次尝试获取锁时，都是通过tryAcquireShared()来进行尝试的。下面看看“获取共享锁”的详细流程。
1. lock()
lock()在ReadLock中，源码如下：
public void lock() {
sync.acquireShared(1);
}
2. acquireShared()
Sync继承于AQS，acquireShared()定义在AQS中。源码如下：
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
说明：acquireShared()首先会通过tryAcquireShared()来尝试获取锁。
尝试成功的话，则不再做任何动作(因为已经成功获取到锁了)。
尝试失败的话，则通过doAcquireShared()来获取锁。doAcquireShared()会获取到锁了才返回。
3. tryAcquireShared()
tryAcquireShared()定义在ReentrantReadWriteLock.java的Sync中，源码如下：
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
// 获取“锁”的状态
int c = getState();
// 如果“锁”是“互斥锁”，并且获取锁的线程不是current线程；则返回-1。
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
// 获取“读取锁”的共享计数
int r = sharedCount(c);
// 如果“不需要阻塞等待”，并且“读取锁”的共享计数小于MAX_COUNT；
// 则通过CAS函数更新“锁的状态”，将“读取锁”的共享计数+1。
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
// 第1次获取“读取锁”。
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
// 如果想要获取锁的线程(current)是第1个获取锁(firstReader)的线程
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
// HoldCounter是用来统计该线程获取“读取锁”的次数。
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != current.getId())
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
// 将该线程获取“读取锁”的次数+1。
rh.count++;
}
return 1;
}
return fullTryAcquireShared(current);
}
说明：tryAcquireShared()的作用是尝试获取“共享锁”。
如果在尝试获取锁时，“不需要阻塞等待”并且“读取锁的共享计数小于MAX_COUNT”，则直接通过CAS函数更新“读取锁的共享计数”，以及将“当前线程获取读取锁的次数+1”。
否则，通过fullTryAcquireShared()获取读取锁。
4. fullTryAcquireShared()
fullTryAcquireShared()在ReentrantReadWriteLock中定义，源码如下：
final int fullTryAcquireShared(Thread current) {
HoldCounter rh = null;
for (;;) {
// 获取“锁”的状态
int c = getState();
// 如果“锁”是“互斥锁”，并且获取锁的线程不是current线程；则返回-1。
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current)
return -1;
// 如果“需要阻塞等待”。
// (01) 当“需要阻塞等待”的线程是第1个获取锁的线程的话，则继续往下执行。
// (02) 当“需要阻塞等待”的线程获取锁的次数=0时，则返回-1。
} else if (readerShouldBlock()) {
// 如果想要获取锁的线程(current)是第1个获取锁(firstReader)的线程
if (firstReader == current) {
} else {
if (rh == null) {
rh = cachedHoldCounter;
if (rh == null || rh.tid != current.getId()) {
rh = readHolds.get();
if (rh.count == 0)
readHolds.remove();
}
}
// 如果当前线程获取锁的计数=0,则返回-1。
if (rh.count == 0)
return -1;
}
}
// 如果“不需要阻塞等待”，则获取“读取锁”的共享统计数；
// 如果共享统计数超过MAX_COUNT，则抛出异常。
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// 将线程获取“读取锁”的次数+1。
if (compareAndSetState(c, c + SHARED_UNIT)) {
// 如果是第1次获取“读取锁”，则更新firstReader和firstReaderHoldCount。
if (sharedCount(c) == 0) {
firstReader = current;
firstReaderHoldCount = 1;
// 如果想要获取锁的线程(current)是第1个获取锁(firstReader)的线程，
// 则将firstReaderHoldCount+1。
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
if (rh == null)
rh = cachedHoldCounter;
if (rh == null || rh.tid != current.getId())
rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
// 更新线程的获取“读取锁”的共享计数
rh.count++;
cachedHoldCounter = rh; // cache for release
}
return 1;
}
}
}
说明：fullTryAcquireShared()会根据“是否需要阻塞等待”，“读取锁的共享计数是否超过限制”等等进行处理。如果不需要阻塞等待，并且锁的共享计数没有超过限制，则通过CAS尝试获取锁，并返回1。
5. doAcquireShared()
doAcquireShared()定义在AQS函数中，源码如下：
private void doAcquireShared(int arg) {
// addWaiter(Node.SHARED)的作用是，创建“当前线程”对应的节点，并将该线程添加到CLH队列中。
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
// 获取“node”的前一节点
final Node p = node.predecessor();
// 如果“当前线程”是CLH队列的表头，则尝试获取共享锁。
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
// 如果“当前线程”不是CLH队列的表头，则通过shouldParkAfterFailedAcquire()判断是否需要等待，
// 需要的话，则通过parkAndCheckInterrupt()进行阻塞等待。若阻塞等待过程中，线程被中断过，则设置interrupted为true。
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
说明：doAcquireShared()的作用是获取共享锁。
它会首先创建线程对应的CLH队列的节点，然后将该节点添加到CLH队列中。CLH队列是管理获取锁的等待线程的队列。
如果“当前线程”是CLH队列的表头，则尝试获取共享锁；否则，则需要通过shouldParkAfterFailedAcquire()判断是否阻塞等待，需要的话，则通过parkAndCheckInterrupt()进行阻塞等待。
doAcquireShared()会通过for循环，不断的进行上面的操作；目的就是获取共享锁。需要注意的是：doAcquireShared()在每一次尝试获取锁时，是通过tryAcquireShared()来执行的！
shouldParkAfterFailedAcquire(), parkAndCheckInterrupt()等函数已经在“Java多线程系列--“JUC锁”03之 公平锁(一) ”中详细介绍过，这里就不再重复说明了。
释放共享锁
释放共享锁的思想，是先通过tryReleaseShared()尝试释放共享锁。尝试成功的话，则通过doReleaseShared()唤醒“其他等待获取共享锁的线程”，并返回true；否则的话，返回flase。
1. unlock()
public void unlock() {
sync.releaseShared(1);
}
说明：该函数实际上调用releaseShared(1)释放共享锁。
2. releaseShared()
releaseShared()在AQS中实现，源码如下：
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
说明：releaseShared()的目的是让当前线程释放它所持有的共享锁。
它首先会通过tryReleaseShared()去尝试释放共享锁。尝试成功，则直接返回；尝试失败，则通过doReleaseShared()去释放共享锁。
3. tryReleaseShared()
tryReleaseShared()定义在ReentrantReadWriteLock中，源码如下：
protected final boolean tryReleaseShared(int unused) {
// 获取当前线程，即释放共享锁的线程。
Thread current = Thread.currentThread();
// 如果想要释放锁的线程(current)是第1个获取锁(firstReader)的线程，
// 并且“第1个获取锁的线程获取锁的次数”=1，则设置firstReader为null；
// 否则，将“第1个获取锁的线程的获取次数”-1。
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount--;
// 获取rh对象，并更新“当前线程获取锁的信息”。
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != current.getId())
rh = readHolds.get();
int count = rh.count;
if (count <= 1) {
readHolds.remove();
if (count <= 0)
throw unmatchedUnlockException();
}
--rh.count;
}
for (;;) {
// 获取锁的状态
int c = getState();
// 将锁的获取次数-1。
int nextc = c - SHARED_UNIT;
// 通过CAS更新锁的状态。
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
说明：tryReleaseShared()的作用是尝试释放共享锁。
4. doReleaseShared()
doReleaseShared()定义在AQS中，源码如下：
private void doReleaseShared() {
for (;;) {
// 获取CLH队列的头节点
Node h = head;
// 如果头节点不为null，并且头节点不等于tail节点。
if (h != null && h != tail) {
// 获取头节点对应的线程的状态
int ws = h.waitStatus;
// 如果头节点对应的线程是SIGNAL状态，则意味着“头节点的下一个节点所对应的线程”需要被unpark唤醒。
if (ws == Node.SIGNAL) {
// 设置“头节点对应的线程状态”为空状态。失败的话，则继续循环。
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue;
// 唤醒“头节点的下一个节点所对应的线程”。
unparkSuccessor(h);
}
// 如果头节点对应的线程是空状态，则设置“文件点对应的线程所拥有的共享锁”为其它线程获取锁的空状态。
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
// 如果头节点发生变化，则继续循环。否则，退出循环。
if (h == head) // loop if head changed
break;
}
}
说明：doReleaseShared()会释放“共享锁”。它会从前往后的遍历CLH队列，依次“唤醒”然后“执行”队列中每个节点对应的线程；最终的目的是让这些线程释放它们所持有的锁。
公平共享锁和非公平共享锁
和互斥锁ReentrantLock一样，ReadLock也分为公平锁和非公平锁。
公平锁和非公平锁的区别，体现在判断是否需要阻塞的函数readerShouldBlock()是不同的。
公平锁的readerShouldBlock()的源码如下：
final boolean readerShouldBlock() {
return hasQueuedPredecessors();
}
在公平共享锁中，如果在当前线程的前面有其他线程在等待获取共享锁，则返回true；否则，返回false。
非公平锁的readerShouldBlock()的源码如下：
final boolean readerShouldBlock() {
return apparentlyFirstQueuedIsExclusive();
}
在非公平共享锁中，它会无视当前线程的前面是否有其他线程在等待获取共享锁。只要该非公平共享锁对应的线程不为null，则返回true。
ReentrantReadWriteLock示例
1 import java.util.concurrent.locks.ReadWriteLock;
2 import java.util.concurrent.locks.ReentrantReadWriteLock;
3
4 public class ReadWriteLockTest1 {
5
6 public static void main(String[] args) {
7 // 创建账户
8 MyCount myCount = new MyCount("4238920615242830", 10000);
9 // 创建用户，并指定账户
10 User user = new User("Tommy", myCount);
11
12 // 分别启动3个“读取账户金钱”的线程 和 3个“设置账户金钱”的线程
13 for (int i=0; i<3; i++) {
14 user.getCash();
15 user.setCash((i+1)*1000);
16 }
17 }
18 }
19
20 class User {
21 private String name; //用户名
22 private MyCount myCount; //所要操作的账户
23 private ReadWriteLock myLock; //执行操作所需的锁对象
24
25 User(String name, MyCount myCount) {
26 this.name = name;
27 this.myCount = myCount;
28 this.myLock = new ReentrantReadWriteLock();
29 }
30
31 public void getCash() {
32 new Thread() {
33 public void run() {
34 myLock.readLock().lock();
35 try {
36 System.out.println(Thread.currentThread().getName() +" getCash start");
37 myCount.getCash();
38 Thread.sleep(1);
39 System.out.println(Thread.currentThread().getName() +" getCash end");
40 } catch (InterruptedException e) {
41 } finally {
42 myLock.readLock().unlock();
43 }
44 }
45 }.start();
46 }
47
48 public void setCash(final int cash) {
49 new Thread() {
50 public void run() {
51 myLock.writeLock().lock();
52 try {
53 System.out.println(Thread.currentThread().getName() +" setCash start");
54 myCount.setCash(cash);
55 Thread.sleep(1);
56 System.out.println(Thread.currentThread().getName() +" setCash end");
57 } catch (InterruptedException e) {
58 } finally {
59 myLock.writeLock().unlock();
60 }
61 }
62 }.start();
63 }
64 }
65
66 class MyCount {
67 private String id; //账号
68 private int cash; //账户余额
69
70 MyCount(String id, int cash) {
71 this.id = id;
72 this.cash = cash;
73 }
74
75 public String getId() {
76 return id;
77 }
78
79 public void setId(String id) {
80 this.id = id;
81 }
82
83 public int getCash() {
84 System.out.println(Thread.currentThread().getName() +" getCash cash="+ cash);
85 return cash;
86 }
87
88 public void setCash(int cash) {
89 System.out.println(Thread.currentThread().getName() +" setCash cash="+ cash);
90 this.cash = cash;
91 }
92 }
运行结果：
Thread-0 getCash start Thread-2 getCash start Thread-0 getCash cash=10000 Thread-2 getCash cash=10000 Thread-0 getCash end Thread-2 getCash end Thread-1 setCash start Thread-1 setCash cash=1000 Thread-1 setCash end Thread-3 setCash start Thread-3 setCash cash=2000 Thread-3 setCash end Thread-4 getCash start Thread-4 getCash cash=2000 Thread-4 getCash end Thread-5 setCash start Thread-5 setCash cash=3000 Thread-5 setCash end
结果说明：
(01) 观察Thread0和Thread-2的运行结果，我们发现，Thread-0启动并获取到“读取锁”，在它还没运行完毕的时候，Thread-2也启动了并且也成功获取到“读取锁”。
因此，“读取锁”支持被多个线程同时获取。
(02) 观察Thread-1,Thread-3,Thread-5这三个“写入锁”的线程。只要“写入锁”被某线程获取，则该线程运行完毕了，才释放该锁。
因此，“写入锁”不支持被多个线程同时获取。
更多内容
2. Java多线程系列--“JUC锁”02之 互斥锁ReentrantLock
3. Java多线程系列--“JUC锁”03之 公平锁(一)
4. Java多线程系列--“JUC锁”04之 公平锁(二)
6. Java多线程系列--“JUC锁”06之 Condition条件
7. Java多线程系列--“JUC锁”07之 LockSupport
扫一扫
389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
