Java多线程系列--“JUC锁”05之 非公平锁

 

概要

前面两章分析了"公平锁的获取和释放机制",这一章开始对“非公平锁”的获取锁/释放锁的过程进行分析。内容包括:
参考代码
获取非公平锁(基于JDK1.7.0_40)
释放非公平锁(基于JDK1.7.0_40)
关于锁的数据结构请参考"Java多线程系列--“JUC锁”03之 公平锁(一) ",锁的使用示例请参考“Java多线程系列--“JUC锁”02之 互斥锁ReentrantLock”。

转载请注明出处:http://www.cnblogs.com/skywang12345/p/3496651.html

 

参考代码

下面给出Java1.7.0_40版本中,ReentrantLock和AQS的源码,仅供参考!

ReentranLock.java

Java多线程系列--“JUC锁”05之 非公平锁
  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 

 41 /**

 42  * A reentrant mutual exclusion {@link Lock} with the same basic

 43  * behavior and semantics as the implicit monitor lock accessed using

 44  * {@code synchronized} methods and statements, but with extended

 45  * capabilities.

 46  *

 47  * <p>A {@code ReentrantLock} is <em>owned</em> by the thread last

 48  * successfully locking, but not yet unlocking it. A thread invoking

 49  * {@code lock} will return, successfully acquiring the lock, when

 50  * the lock is not owned by another thread. The method will return

 51  * immediately if the current thread already owns the lock. This can

 52  * be checked using methods {@link #isHeldByCurrentThread}, and {@link

 53  * #getHoldCount}.

 54  *

 55  * <p>The constructor for this class accepts an optional

 56  * <em>fairness</em> parameter.  When set {@code true}, under

 57  * contention, locks favor granting access to the longest-waiting

 58  * thread.  Otherwise this lock does not guarantee any particular

 59  * access order.  Programs using fair locks accessed by many threads

 60  * may display lower overall throughput (i.e., are slower; often much

 61  * slower) than those using the default setting, but have smaller

 62  * variances in times to obtain locks and guarantee lack of

 63  * starvation. Note however, that fairness of locks does not guarantee

 64  * fairness of thread scheduling. Thus, one of many threads using a

 65  * fair lock may obtain it multiple times in succession while other

 66  * active threads are not progressing and not currently holding the

 67  * lock.

 68  * Also note that the untimed {@link #tryLock() tryLock} method does not

 69  * honor the fairness setting. It will succeed if the lock

 70  * is available even if other threads are waiting.

 71  *

 72  * <p>It is recommended practice to <em>always</em> immediately

 73  * follow a call to {@code lock} with a {@code try} block, most

 74  * typically in a before/after construction such as:

 75  *

 76  * <pre>

 77  * class X {

 78  *   private final ReentrantLock lock = new ReentrantLock();

 79  *   // ...

 80  *

 81  *   public void m() {

 82  *     lock.lock();  // block until condition holds

 83  *     try {

 84  *       // ... method body

 85  *     } finally {

 86  *       lock.unlock()

 87  *     }

 88  *   }

 89  * }

 90  * </pre>

 91  *

 92  * <p>In addition to implementing the {@link Lock} interface, this

 93  * class defines methods {@code isLocked} and

 94  * {@code getLockQueueLength}, as well as some associated

 95  * {@code protected} access methods that may be useful for

 96  * instrumentation and monitoring.

 97  *

 98  * <p>Serialization of this class behaves in the same way as built-in

 99  * locks: a deserialized lock is in the unlocked state, regardless of

100  * its state when serialized.

101  *

102  * <p>This lock supports a maximum of 2147483647 recursive locks by

103  * the same thread. Attempts to exceed this limit result in

104  * {@link Error} throws from locking methods.

105  *

106  * @since 1.5

107  * @author Doug Lea

108  */

109 public class ReentrantLock implements Lock, java.io.Serializable {

110     private static final long serialVersionUID = 7373984872572414699L;

111     /** Synchronizer providing all implementation mechanics */

112     private final Sync sync;

113 

114     /**

115      * Base of synchronization control for this lock. Subclassed

116      * into fair and nonfair versions below. Uses AQS state to

117      * represent the number of holds on the lock.

118      */

119     abstract static class Sync extends AbstractQueuedSynchronizer {

120         private static final long serialVersionUID = -5179523762034025860L;

121 

122         /**

123          * Performs {@link Lock#lock}. The main reason for subclassing

124          * is to allow fast path for nonfair version.

125          */

126         abstract void lock();

127 

128         /**

129          * Performs non-fair tryLock.  tryAcquire is

130          * implemented in subclasses, but both need nonfair

131          * try for trylock method.

132          */

133         final boolean nonfairTryAcquire(int acquires) {

134             final Thread current = Thread.currentThread();

135             int c = getState();

136             if (c == 0) {

137                 if (compareAndSetState(0, acquires)) {

138                     setExclusiveOwnerThread(current);

139                     return true;

140                 }

141             }

142             else if (current == getExclusiveOwnerThread()) {

143                 int nextc = c + acquires;

144                 if (nextc < 0) // overflow

145                     throw new Error("Maximum lock count exceeded");

146                 setState(nextc);

147                 return true;

148             }

149             return false;

150         }

151 

152         protected final boolean tryRelease(int releases) {

153             int c = getState() - releases;

154             if (Thread.currentThread() != getExclusiveOwnerThread())

155                 throw new IllegalMonitorStateException();

156             boolean free = false;

157             if (c == 0) {

158                 free = true;

159                 setExclusiveOwnerThread(null);

160             }

161             setState(c);

162             return free;

163         }

164 

165         protected final boolean isHeldExclusively() {

166             // While we must in general read state before owner,

167             // we don't need to do so to check if current thread is owner

168             return getExclusiveOwnerThread() == Thread.currentThread();

169         }

170 

171         final ConditionObject newCondition() {

172             return new ConditionObject();

173         }

174 

175         // Methods relayed from outer class

176 

177         final Thread getOwner() {

178             return getState() == 0 ? null : getExclusiveOwnerThread();

179         }

180 

181         final int getHoldCount() {

182             return isHeldExclusively() ? getState() : 0;

183         }

184 

185         final boolean isLocked() {

186             return getState() != 0;

187         }

188 

189         /**

190          * Reconstitutes this lock instance from a stream.

191          * @param s the stream

192          */

193         private void readObject(java.io.ObjectInputStream s)

194             throws java.io.IOException, ClassNotFoundException {

195             s.defaultReadObject();

196             setState(0); // reset to unlocked state

197         }

198     }

199 

200     /**

201      * Sync object for non-fair locks

202      */

203     static final class NonfairSync extends Sync {

204         private static final long serialVersionUID = 7316153563782823691L;

205 

206         /**

207          * Performs lock.  Try immediate barge, backing up to normal

208          * acquire on failure.

209          */

210         final void lock() {

211             if (compareAndSetState(0, 1))

212                 setExclusiveOwnerThread(Thread.currentThread());

213             else

214                 acquire(1);

215         }

216 

217         protected final boolean tryAcquire(int acquires) {

218             return nonfairTryAcquire(acquires);

219         }

220     }

221 

222     /**

223      * Sync object for fair locks

224      */

225     static final class FairSync extends Sync {

226         private static final long serialVersionUID = -3000897897090466540L;

227 

228         final void lock() {

229             acquire(1);

230         }

231 

232         /**

233          * Fair version of tryAcquire.  Don't grant access unless

234          * recursive call or no waiters or is first.

235          */

236         protected final boolean tryAcquire(int acquires) {

237             final Thread current = Thread.currentThread();

238             int c = getState();

239             if (c == 0) {

240                 if (!hasQueuedPredecessors() &&

241                     compareAndSetState(0, acquires)) {

242                     setExclusiveOwnerThread(current);

243                     return true;

244                 }

245             }

246             else if (current == getExclusiveOwnerThread()) {

247                 int nextc = c + acquires;

248                 if (nextc < 0)

249                     throw new Error("Maximum lock count exceeded");

250                 setState(nextc);

251                 return true;

252             }

253             return false;

254         }

255     }

256 

257     /**

258      * Creates an instance of {@code ReentrantLock}.

259      * This is equivalent to using {@code ReentrantLock(false)}.

260      */

261     public ReentrantLock() {

262         sync = new NonfairSync();

263     }

264 

265     /**

266      * Creates an instance of {@code ReentrantLock} with the

267      * given fairness policy.

268      *

269      * @param fair {@code true} if this lock should use a fair ordering policy

270      */

271     public ReentrantLock(boolean fair) {

272         sync = fair ? new FairSync() : new NonfairSync();

273     }

274 

275     /**

276      * Acquires the lock.

277      *

278      * <p>Acquires the lock if it is not held by another thread and returns

279      * immediately, setting the lock hold count to one.

280      *

281      * <p>If the current thread already holds the lock then the hold

282      * count is incremented by one and the method returns immediately.

283      *

284      * <p>If the lock is held by another thread then the

285      * current thread becomes disabled for thread scheduling

286      * purposes and lies dormant until the lock has been acquired,

287      * at which time the lock hold count is set to one.

288      */

289     public void lock() {

290         sync.lock();

291     }

292 

293     /**

294      * Acquires the lock unless the current thread is

295      * {@linkplain Thread#interrupt interrupted}.

296      *

297      * <p>Acquires the lock if it is not held by another thread and returns

298      * immediately, setting the lock hold count to one.

299      *

300      * <p>If the current thread already holds this lock then the hold count

301      * is incremented by one and the method returns immediately.

302      *

303      * <p>If the lock is held by another thread then the

304      * current thread becomes disabled for thread scheduling

305      * purposes and lies dormant until one of two things happens:

306      *

307      * <ul>

308      *

309      * <li>The lock is acquired by the current thread; or

310      *

311      * <li>Some other thread {@linkplain Thread#interrupt interrupts} the

312      * current thread.

313      *

314      * </ul>

315      *

316      * <p>If the lock is acquired by the current thread then the lock hold

317      * count is set to one.

318      *

319      * <p>If the current thread:

320      *

321      * <ul>

322      *

323      * <li>has its interrupted status set on entry to this method; or

324      *

325      * <li>is {@linkplain Thread#interrupt interrupted} while acquiring

326      * the lock,

327      *

328      * </ul>

329      *

330      * then {@link InterruptedException} is thrown and the current thread's

331      * interrupted status is cleared.

332      *

333      * <p>In this implementation, as this method is an explicit

334      * interruption point, preference is given to responding to the

335      * interrupt over normal or reentrant acquisition of the lock.

336      *

337      * @throws InterruptedException if the current thread is interrupted

338      */

339     public void lockInterruptibly() throws InterruptedException {

340         sync.acquireInterruptibly(1);

341     }

342 

343     /**

344      * Acquires the lock only if it is not held by another thread at the time

345      * of invocation.

346      *

347      * <p>Acquires the lock if it is not held by another thread and

348      * returns immediately with the value {@code true}, setting the

349      * lock hold count to one. Even when this lock has been set to use a

350      * fair ordering policy, a call to {@code tryLock()} <em>will</em>

351      * immediately acquire the lock if it is available, whether or not

352      * other threads are currently waiting for the lock.

353      * This &quot;barging&quot; behavior can be useful in certain

354      * circumstances, even though it breaks fairness. If you want to honor

355      * the fairness setting for this lock, then use

356      * {@link #tryLock(long, TimeUnit) tryLock(0, TimeUnit.SECONDS) }

357      * which is almost equivalent (it also detects interruption).

358      *

359      * <p> If the current thread already holds this lock then the hold

360      * count is incremented by one and the method returns {@code true}.

361      *

362      * <p>If the lock is held by another thread then this method will return

363      * immediately with the value {@code false}.

364      *

365      * @return {@code true} if the lock was free and was acquired by the

366      *         current thread, or the lock was already held by the current

367      *         thread; and {@code false} otherwise

368      */

369     public boolean tryLock() {

370         return sync.nonfairTryAcquire(1);

371     }

372 

373     /**

374      * Acquires the lock if it is not held by another thread within the given

375      * waiting time and the current thread has not been

376      * {@linkplain Thread#interrupt interrupted}.

377      *

378      * <p>Acquires the lock if it is not held by another thread and returns

379      * immediately with the value {@code true}, setting the lock hold count

380      * to one. If this lock has been set to use a fair ordering policy then

381      * an available lock <em>will not</em> be acquired if any other threads

382      * are waiting for the lock. This is in contrast to the {@link #tryLock()}

383      * method. If you want a timed {@code tryLock} that does permit barging on

384      * a fair lock then combine the timed and un-timed forms together:

385      *

386      * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }

387      * </pre>

388      *

389      * <p>If the current thread

390      * already holds this lock then the hold count is incremented by one and

391      * the method returns {@code true}.

392      *

393      * <p>If the lock is held by another thread then the

394      * current thread becomes disabled for thread scheduling

395      * purposes and lies dormant until one of three things happens:

396      *

397      * <ul>

398      *

399      * <li>The lock is acquired by the current thread; or

400      *

401      * <li>Some other thread {@linkplain Thread#interrupt interrupts}

402      * the current thread; or

403      *

404      * <li>The specified waiting time elapses

405      *

406      * </ul>

407      *

408      * <p>If the lock is acquired then the value {@code true} is returned and

409      * the lock hold count is set to one.

410      *

411      * <p>If the current thread:

412      *

413      * <ul>

414      *

415      * <li>has its interrupted status set on entry to this method; or

416      *

417      * <li>is {@linkplain Thread#interrupt interrupted} while

418      * acquiring the lock,

419      *

420      * </ul>

421      * then {@link InterruptedException} is thrown and the current thread's

422      * interrupted status is cleared.

423      *

424      * <p>If the specified waiting time elapses then the value {@code false}

425      * is returned.  If the time is less than or equal to zero, the method

426      * will not wait at all.

427      *

428      * <p>In this implementation, as this method is an explicit

429      * interruption point, preference is given to responding to the

430      * interrupt over normal or reentrant acquisition of the lock, and

431      * over reporting the elapse of the waiting time.

432      *

433      * @param timeout the time to wait for the lock

434      * @param unit the time unit of the timeout argument

435      * @return {@code true} if the lock was free and was acquired by the

436      *         current thread, or the lock was already held by the current

437      *         thread; and {@code false} if the waiting time elapsed before

438      *         the lock could be acquired

439      * @throws InterruptedException if the current thread is interrupted

440      * @throws NullPointerException if the time unit is null

441      *

442      */

443     public boolean tryLock(long timeout, TimeUnit unit)

444             throws InterruptedException {

445         return sync.tryAcquireNanos(1, unit.toNanos(timeout));

446     }

447 

448     /**

449      * Attempts to release this lock.

450      *

451      * <p>If the current thread is the holder of this lock then the hold

452      * count is decremented.  If the hold count is now zero then the lock

453      * is released.  If the current thread is not the holder of this

454      * lock then {@link IllegalMonitorStateException} is thrown.

455      *

456      * @throws IllegalMonitorStateException if the current thread does not

457      *         hold this lock

458      */

459     public void unlock() {

460         sync.release(1);

461     }

462 

463     /**

464      * Returns a {@link Condition} instance for use with this

465      * {@link Lock} instance.

466      *

467      * <p>The returned {@link Condition} instance supports the same

468      * usages as do the {@link Object} monitor methods ({@link

469      * Object#wait() wait}, {@link Object#notify notify}, and {@link

470      * Object#notifyAll notifyAll}) when used with the built-in

471      * monitor lock.

472      *

473      * <ul>

474      *

475      * <li>If this lock is not held when any of the {@link Condition}

476      * {@linkplain Condition#await() waiting} or {@linkplain

477      * Condition#signal signalling} methods are called, then an {@link

478      * IllegalMonitorStateException} is thrown.

479      *

480      * <li>When the condition {@linkplain Condition#await() waiting}

481      * methods are called the lock is released and, before they

482      * return, the lock is reacquired and the lock hold count restored

483      * to what it was when the method was called.

484      *

485      * <li>If a thread is {@linkplain Thread#interrupt interrupted}

486      * while waiting then the wait will terminate, an {@link

487      * InterruptedException} will be thrown, and the thread's

488      * interrupted status will be cleared.

489      *

490      * <li> Waiting threads are signalled in FIFO order.

491      *

492      * <li>The ordering of lock reacquisition for threads returning

493      * from waiting methods is the same as for threads initially

494      * acquiring the lock, which is in the default case not specified,

495      * but for <em>fair</em> locks favors those threads that have been

496      * waiting the longest.

497      *

498      * </ul>

499      *

500      * @return the Condition object

501      */

502     public Condition newCondition() {

503         return sync.newCondition();

504     }

505 

506     /**

507      * Queries the number of holds on this lock by the current thread.

508      *

509      * <p>A thread has a hold on a lock for each lock action that is not

510      * matched by an unlock action.

511      *

512      * <p>The hold count information is typically only used for testing and

513      * debugging purposes. For example, if a certain section of code should

514      * not be entered with the lock already held then we can assert that

515      * fact:

516      *

517      * <pre>

518      * class X {

519      *   ReentrantLock lock = new ReentrantLock();

520      *   // ...

521      *   public void m() {

522      *     assert lock.getHoldCount() == 0;

523      *     lock.lock();

524      *     try {

525      *       // ... method body

526      *     } finally {

527      *       lock.unlock();

528      *     }

529      *   }

530      * }

531      * </pre>

532      *

533      * @return the number of holds on this lock by the current thread,

534      *         or zero if this lock is not held by the current thread

535      */

536     public int getHoldCount() {

537         return sync.getHoldCount();

538     }

539 

540     /**

541      * Queries if this lock is held by the current thread.

542      *

543      * <p>Analogous to the {@link Thread#holdsLock} method for built-in

544      * monitor locks, this method is typically used for debugging and

545      * testing. For example, a method that should only be called while

546      * a lock is held can assert that this is the case:

547      *

548      * <pre>

549      * class X {

550      *   ReentrantLock lock = new ReentrantLock();

551      *   // ...

552      *

553      *   public void m() {

554      *       assert lock.isHeldByCurrentThread();

555      *       // ... method body

556      *   }

557      * }

558      * </pre>

559      *

560      * <p>It can also be used to ensure that a reentrant lock is used

561      * in a non-reentrant manner, for example:

562      *

563      * <pre>

564      * class X {

565      *   ReentrantLock lock = new ReentrantLock();

566      *   // ...

567      *

568      *   public void m() {

569      *       assert !lock.isHeldByCurrentThread();

570      *       lock.lock();

571      *       try {

572      *           // ... method body

573      *       } finally {

574      *           lock.unlock();

575      *       }

576      *   }

577      * }

578      * </pre>

579      *

580      * @return {@code true} if current thread holds this lock and

581      *         {@code false} otherwise

582      */

583     public boolean isHeldByCurrentThread() {

584         return sync.isHeldExclusively();

585     }

586 

587     /**

588      * Queries if this lock is held by any thread. This method is

589      * designed for use in monitoring of the system state,

590      * not for synchronization control.

591      *

592      * @return {@code true} if any thread holds this lock and

593      *         {@code false} otherwise

594      */

595     public boolean isLocked() {

596         return sync.isLocked();

597     }

598 

599     /**

600      * Returns {@code true} if this lock has fairness set true.

601      *

602      * @return {@code true} if this lock has fairness set true

603      */

604     public final boolean isFair() {

605         return sync instanceof FairSync;

606     }

607 

608     /**

609      * Returns the thread that currently owns this lock, or

610      * {@code null} if not owned. When this method is called by a

611      * thread that is not the owner, the return value reflects a

612      * best-effort approximation of current lock status. For example,

613      * the owner may be momentarily {@code null} even if there are

614      * threads trying to acquire the lock but have not yet done so.

615      * This method is designed to facilitate construction of

616      * subclasses that provide more extensive lock monitoring

617      * facilities.

618      *

619      * @return the owner, or {@code null} if not owned

620      */

621     protected Thread getOwner() {

622         return sync.getOwner();

623     }

624 

625     /**

626      * Queries whether any threads are waiting to acquire this lock. Note that

627      * because cancellations may occur at any time, a {@code true}

628      * return does not guarantee that any other thread will ever

629      * acquire this lock.  This method is designed primarily for use in

630      * monitoring of the system state.

631      *

632      * @return {@code true} if there may be other threads waiting to

633      *         acquire the lock

634      */

635     public final boolean hasQueuedThreads() {

636         return sync.hasQueuedThreads();

637     }

638 

639 

640     /**

641      * Queries whether the given thread is waiting to acquire this

642      * lock. Note that because cancellations may occur at any time, a

643      * {@code true} return does not guarantee that this thread

644      * will ever acquire this lock.  This method is designed primarily for use

645      * in monitoring of the system state.

646      *

647      * @param thread the thread

648      * @return {@code true} if the given thread is queued waiting for this lock

649      * @throws NullPointerException if the thread is null

650      */

651     public final boolean hasQueuedThread(Thread thread) {

652         return sync.isQueued(thread);

653     }

654 

655 

656     /**

657      * Returns an estimate of the number of threads waiting to

658      * acquire this lock.  The value is only an estimate because the number of

659      * threads may change dynamically while this method traverses

660      * internal data structures.  This method is designed for use in

661      * monitoring of the system state, not for synchronization

662      * control.

663      *

664      * @return the estimated number of threads waiting for this lock

665      */

666     public final int getQueueLength() {

667         return sync.getQueueLength();

668     }

669 

670     /**

671      * Returns a collection containing threads that may be waiting to

672      * acquire this lock.  Because the actual set of threads may change

673      * dynamically while constructing this result, the returned

674      * collection is only a best-effort estimate.  The elements of the

675      * returned collection are in no particular order.  This method is

676      * designed to facilitate construction of subclasses that provide

677      * more extensive monitoring facilities.

678      *

679      * @return the collection of threads

680      */

681     protected Collection<Thread> getQueuedThreads() {

682         return sync.getQueuedThreads();

683     }

684 

685     /**

686      * Queries whether any threads are waiting on the given condition

687      * associated with this lock. Note that because timeouts and

688      * interrupts may occur at any time, a {@code true} return does

689      * not guarantee that a future {@code signal} will awaken any

690      * threads.  This method is designed primarily for use in

691      * monitoring of the system state.

692      *

693      * @param condition the condition

694      * @return {@code true} if there are any waiting threads

695      * @throws IllegalMonitorStateException if this lock is not held

696      * @throws IllegalArgumentException if the given condition is

697      *         not associated with this lock

698      * @throws NullPointerException if the condition is null

699      */

700     public boolean hasWaiters(Condition condition) {

701         if (condition == null)

702             throw new NullPointerException();

703         if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))

704             throw new IllegalArgumentException("not owner");

705         return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);

706     }

707 

708     /**

709      * Returns an estimate of the number of threads waiting on the

710      * given condition associated with this lock. Note that because

711      * timeouts and interrupts may occur at any time, the estimate

712      * serves only as an upper bound on the actual number of waiters.

713      * This method is designed for use in monitoring of the system

714      * state, not for synchronization control.

715      *

716      * @param condition the condition

717      * @return the estimated number of waiting threads

718      * @throws IllegalMonitorStateException if this lock is not held

719      * @throws IllegalArgumentException if the given condition is

720      *         not associated with this lock

721      * @throws NullPointerException if the condition is null

722      */

723     public int getWaitQueueLength(Condition condition) {

724         if (condition == null)

725             throw new NullPointerException();

726         if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))

727             throw new IllegalArgumentException("not owner");

728         return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);

729     }

730 

731     /**

732      * Returns a collection containing those threads that may be

733      * waiting on the given condition associated with this lock.

734      * Because the actual set of threads may change dynamically while

735      * constructing this result, the returned collection is only a

736      * best-effort estimate. The elements of the returned collection

737      * are in no particular order.  This method is designed to

738      * facilitate construction of subclasses that provide more

739      * extensive condition monitoring facilities.

740      *

741      * @param condition the condition

742      * @return the collection of threads

743      * @throws IllegalMonitorStateException if this lock is not held

744      * @throws IllegalArgumentException if the given condition is

745      *         not associated with this lock

746      * @throws NullPointerException if the condition is null

747      */

748     protected Collection<Thread> getWaitingThreads(Condition condition) {

749         if (condition == null)

750             throw new NullPointerException();

751         if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))

752             throw new IllegalArgumentException("not owner");

753         return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);

754     }

755 

756     /**

757      * Returns a string identifying this lock, as well as its lock state.

758      * The state, in brackets, includes either the String {@code "Unlocked"}

759      * or the String {@code "Locked by"} followed by the

760      * {@linkplain Thread#getName name} of the owning thread.

761      *

762      * @return a string identifying this lock, as well as its lock state

763      */

764     public String toString() {

765         Thread o = sync.getOwner();

766         return super.toString() + ((o == null) ?

767                                    "[Unlocked]" :

768                                    "[Locked by thread " + o.getName() + "]");

769     }

770 }
View Code

 

AQS(AbstractQueuedSynchronizer.java)

Java多线程系列--“JUC锁”05之 非公平锁
   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 &quot;understand&quot; 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  * &quot;spin&quot; 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 }
View Code

 

获取非公平锁(基于JDK1.7.0_40)

非公平锁和公平锁在获取锁的方法上,流程是一样的;它们的区别主要表现在“尝试获取锁的机制不同”。简单点说,“公平锁”在每次尝试获取锁时,都是采用公平策略(根据等待队列依次排序等待);而“非公平锁”在每次尝试获取锁时,都是采用的非公平策略(无视等待队列,直接尝试获取锁,如果锁是空闲的,即可获取状态,则获取锁)。
在前面的“Java多线程系列--“JUC锁”03之 公平锁(一)”中,已经详细介绍了获取公平锁的流程和机制;下面,通过代码分析以下获取非公平锁的流程。

 

1. lock()

lock()在ReentrantLock.java的NonfairSync类中实现,它的源码如下:

final void lock() {

    if (compareAndSetState(0, 1))

        setExclusiveOwnerThread(Thread.currentThread());

    else

        acquire(1);

}

说明
lock()会先通过compareAndSet(0, 1)来判断“锁”是不是空闲状态。是的话,“当前线程”直接获取“锁”;否则的话,调用acquire(1)获取锁。
(01) compareAndSetState()是CAS函数,它的作用是比较并设置当前锁的状态。若锁的状态值为0,则设置锁的状态值为1。
(02) setExclusiveOwnerThread(Thread.currentThread())的作用是,设置“当前线程”为“锁”的持有者。

“公平锁”和“非公平锁”关于lock()的对比

公平锁   -- 公平锁的lock()函数,会直接调用acquire(1)。 非公平锁 -- 非公平锁会先判断当前锁的状态是不是空闲,是的话,就不排队,而是直接获取锁。

 

2. acquire()

acquire()在AQS中实现的,它的源码如下:

public final void acquire(int arg) {

    if (!tryAcquire(arg) &&

        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

        selfInterrupt();

}

(01) “当前线程”首先通过tryAcquire()尝试获取锁。获取成功的话,直接返回;尝试失败的话,进入到等待队列依次排序,然后获取锁。
(02) “当前线程”尝试失败的情况下,会先通过addWaiter(Node.EXCLUSIVE)来将“当前线程”加入到"CLH队列(非阻塞的FIFO队列)"末尾。
(03) 然后,调用acquireQueued()获取锁。在acquireQueued()中,当前线程会等待它在“CLH队列”中前面的所有线程执行并释放锁之后,才能获取锁并返回。如果“当前线程”在休眠等待过程中被中断过,则调用selfInterrupt()来自己产生一个中断。

“公平锁”和“非公平锁”关于acquire()的对比

公平锁和非公平锁,只有tryAcquire()函数的实现不同;即它们尝试获取锁的机制不同。这就是我们所说的“它们获取锁策略的不同所在之处”!
在“Java多线程系列--“JUC锁”03之 公平锁(一)”中,已经详细介绍了acquire()涉及到的各个函数。这里仅对它们有差异的函数tryAcquire()进行说明。

 

非公平锁的tryAcquire()在ReentrantLock.java的NonfairSync类中实现,源码如下:

protected final boolean tryAcquire(int acquires) {

    return nonfairTryAcquire(acquires);

}

 

nonfairTryAcquire()在ReentrantLock.java的Sync类中实现,源码如下:

final boolean nonfairTryAcquire(int acquires) {

    // 获取“当前线程”

    final Thread current = Thread.currentThread();

    // 获取“锁”的状态

    int c = getState();

    // c=0意味着“锁没有被任何线程锁拥有”

    if (c == 0) {

        // 若“锁没有被任何线程锁拥有”,则通过CAS函数设置“锁”的状态为acquires。

        // 同时,设置“当前线程”为锁的持有者。

        if (compareAndSetState(0, acquires)) {

            setExclusiveOwnerThread(current);

            return true;

        }

    }

    else if (current == getExclusiveOwnerThread()) {

        // 如果“锁”的持有者已经是“当前线程”,

        // 则将更新锁的状态。

        int nextc = c + acquires;

        if (nextc < 0) // overflow

            throw new Error("Maximum lock count exceeded");

        setState(nextc);

        return true;

    }

    return false;

}

说明
根据代码,我们可以分析出,tryAcquire()的作用就是尝试去获取锁。
(01) 如果“锁”没有被任何线程拥有,则通过CAS函数设置“锁”的状态为acquires,同时,设置“当前线程”为锁的持有者,然后返回true。
(02) 如果“锁”的持有者已经是当前线程,则将更新锁的状态即可。
(03) 如果不术语上面的两种情况,则认为尝试失败。

“公平锁”和“非公平锁”关于tryAcquire()的对比

公平锁和非公平锁,它们尝试获取锁的方式不同。

公平锁在尝试获取锁时,即使“锁”没有被任何线程锁持有,它也会判断自己是不是CLH等待队列的表头;是的话,才获取锁。

而非公平锁在尝试获取锁时,如果“锁”没有被任何线程持有,则不管它在CLH队列的何处,它都直接获取锁。

 

释放非公平锁(基于JDK1.7.0_40)

非公平锁和公平锁在释放锁的方法和策略上是一样的。
而在前面的“Java多线程系列--“JUC锁”04之 公平锁(二) ”中,已经对“释放公平锁”进行了介绍;这里就不再重复的进行说明。

 

总结
公平锁和非公平锁的区别,是在获取锁的机制上的区别。表现在,在尝试获取锁时 —— 公平锁,只有在当前线程是CLH等待队列的表头时,才获取锁;而非公平锁,只要当前锁处于空闲状态,则直接获取锁,而不管CLH等待队列中的顺序。
只有当非公平锁尝试获取锁失败的时候,它才会像公平锁一样,进入CLH等待队列排序等待。

 


更多内容

1. Java多线程系列--“JUC锁”01之 框架 

2. Java多线程系列--“JUC锁”02之 互斥锁ReentrantLock 

3. Java多线程系列--“JUC锁”03之 公平锁(一) 

4. Java多线程系列--“JUC锁”04之 公平锁(二) 

5. Java多线程系列目录(共xx篇) 

 

你可能感兴趣的:(java多线程)