1 /* 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * 4 * This code is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 only, as 6 * published by the Free Software Foundation. Oracle designates this 7 * particular file as subject to the "Classpath" exception as provided 8 * by Oracle in the LICENSE file that accompanied this code. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 */ 24 25 /* 26 * This file is available under and governed by the GNU General Public 27 * License version 2 only, as published by the Free Software Foundation. 28 * However, the following notice accompanied the original version of this 29 * file: 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/licenses/publicdomain 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 static abstract 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 final static 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 final static 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 "barging" 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) throws InterruptedException { 444 return sync.tryAcquireNanos(1, unit.toNanos(timeout)); 445 } 446 447 /** 448 * Attempts to release this lock. 449 * 450 * <p>If the current thread is the holder of this lock then the hold 451 * count is decremented. If the hold count is now zero then the lock 452 * is released. If the current thread is not the holder of this 453 * lock then {@link IllegalMonitorStateException} is thrown. 454 * 455 * @throws IllegalMonitorStateException if the current thread does not 456 * hold this lock 457 */ 458 public void unlock() { 459 sync.release(1); 460 } 461 462 /** 463 * Returns a {@link Condition} instance for use with this 464 * {@link Lock} instance. 465 * 466 * <p>The returned {@link Condition} instance supports the same 467 * usages as do the {@link Object} monitor methods ({@link 468 * Object#wait() wait}, {@link Object#notify notify}, and {@link 469 * Object#notifyAll notifyAll}) when used with the built-in 470 * monitor lock. 471 * 472 * <ul> 473 * 474 * <li>If this lock is not held when any of the {@link Condition} 475 * {@linkplain Condition#await() waiting} or {@linkplain 476 * Condition#signal signalling} methods are called, then an {@link 477 * IllegalMonitorStateException} is thrown. 478 * 479 * <li>When the condition {@linkplain Condition#await() waiting} 480 * methods are called the lock is released and, before they 481 * return, the lock is reacquired and the lock hold count restored 482 * to what it was when the method was called. 483 * 484 * <li>If a thread is {@linkplain Thread#interrupt interrupted} 485 * while waiting then the wait will terminate, an {@link 486 * InterruptedException} will be thrown, and the thread's 487 * interrupted status will be cleared. 488 * 489 * <li> Waiting threads are signalled in FIFO order. 490 * 491 * <li>The ordering of lock reacquisition for threads returning 492 * from waiting methods is the same as for threads initially 493 * acquiring the lock, which is in the default case not specified, 494 * but for <em>fair</em> locks favors those threads that have been 495 * waiting the longest. 496 * 497 * </ul> 498 * 499 * @return the Condition object 500 */ 501 public Condition newCondition() { 502 return sync.newCondition(); 503 } 504 505 /** 506 * Queries the number of holds on this lock by the current thread. 507 * 508 * <p>A thread has a hold on a lock for each lock action that is not 509 * matched by an unlock action. 510 * 511 * <p>The hold count information is typically only used for testing and 512 * debugging purposes. For example, if a certain section of code should 513 * not be entered with the lock already held then we can assert that 514 * fact: 515 * 516 * <pre> 517 * class X { 518 * ReentrantLock lock = new ReentrantLock(); 519 * // ... 520 * public void m() { 521 * assert lock.getHoldCount() == 0; 522 * lock.lock(); 523 * try { 524 * // ... method body 525 * } finally { 526 * lock.unlock(); 527 * } 528 * } 529 * } 530 * </pre> 531 * 532 * @return the number of holds on this lock by the current thread, 533 * or zero if this lock is not held by the current thread 534 */ 535 public int getHoldCount() { 536 return sync.getHoldCount(); 537 } 538 539 /** 540 * Queries if this lock is held by the current thread. 541 * 542 * <p>Analogous to the {@link Thread#holdsLock} method for built-in 543 * monitor locks, this method is typically used for debugging and 544 * testing. For example, a method that should only be called while 545 * a lock is held can assert that this is the case: 546 * 547 * <pre> 548 * class X { 549 * ReentrantLock lock = new ReentrantLock(); 550 * // ... 551 * 552 * public void m() { 553 * assert lock.isHeldByCurrentThread(); 554 * // ... method body 555 * } 556 * } 557 * </pre> 558 * 559 * <p>It can also be used to ensure that a reentrant lock is used 560 * in a non-reentrant manner, for example: 561 * 562 * <pre> 563 * class X { 564 * ReentrantLock lock = new ReentrantLock(); 565 * // ... 566 * 567 * public void m() { 568 * assert !lock.isHeldByCurrentThread(); 569 * lock.lock(); 570 * try { 571 * // ... method body 572 * } finally { 573 * lock.unlock(); 574 * } 575 * } 576 * } 577 * </pre> 578 * 579 * @return {@code true} if current thread holds this lock and 580 * {@code false} otherwise 581 */ 582 public boolean isHeldByCurrentThread() { 583 return sync.isHeldExclusively(); 584 } 585 586 /** 587 * Queries if this lock is held by any thread. This method is 588 * designed for use in monitoring of the system state, 589 * not for synchronization control. 590 * 591 * @return {@code true} if any thread holds this lock and 592 * {@code false} otherwise 593 */ 594 public boolean isLocked() { 595 return sync.isLocked(); 596 } 597 598 /** 599 * Returns {@code true} if this lock has fairness set true. 600 * 601 * @return {@code true} if this lock has fairness set true 602 */ 603 public final boolean isFair() { 604 return sync instanceof FairSync; 605 } 606 607 /** 608 * Returns the thread that currently owns this lock, or 609 * {@code null} if not owned. When this method is called by a 610 * thread that is not the owner, the return value reflects a 611 * best-effort approximation of current lock status. For example, 612 * the owner may be momentarily {@code null} even if there are 613 * threads trying to acquire the lock but have not yet done so. 614 * This method is designed to facilitate construction of 615 * subclasses that provide more extensive lock monitoring 616 * facilities. 617 * 618 * @return the owner, or {@code null} if not owned 619 */ 620 protected Thread getOwner() { 621 return sync.getOwner(); 622 } 623 624 /** 625 * Queries whether any threads are waiting to acquire this lock. Note that 626 * because cancellations may occur at any time, a {@code true} 627 * return does not guarantee that any other thread will ever 628 * acquire this lock. This method is designed primarily for use in 629 * monitoring of the system state. 630 * 631 * @return {@code true} if there may be other threads waiting to 632 * acquire the lock 633 */ 634 public final boolean hasQueuedThreads() { 635 return sync.hasQueuedThreads(); 636 } 637 638 639 /** 640 * Queries whether the given thread is waiting to acquire this 641 * lock. Note that because cancellations may occur at any time, a 642 * {@code true} return does not guarantee that this thread 643 * will ever acquire this lock. This method is designed primarily for use 644 * in monitoring of the system state. 645 * 646 * @param thread the thread 647 * @return {@code true} if the given thread is queued waiting for this lock 648 * @throws NullPointerException if the thread is null 649 */ 650 public final boolean hasQueuedThread(Thread thread) { 651 return sync.isQueued(thread); 652 } 653 654 655 /** 656 * Returns an estimate of the number of threads waiting to 657 * acquire this lock. The value is only an estimate because the number of 658 * threads may change dynamically while this method traverses 659 * internal data structures. This method is designed for use in 660 * monitoring of the system state, not for synchronization 661 * control. 662 * 663 * @return the estimated number of threads waiting for this lock 664 */ 665 public final int getQueueLength() { 666 return sync.getQueueLength(); 667 } 668 669 /** 670 * Returns a collection containing threads that may be waiting to 671 * acquire this lock. Because the actual set of threads may change 672 * dynamically while constructing this result, the returned 673 * collection is only a best-effort estimate. The elements of the 674 * returned collection are in no particular order. This method is 675 * designed to facilitate construction of subclasses that provide 676 * more extensive monitoring facilities. 677 * 678 * @return the collection of threads 679 */ 680 protected Collection<Thread> getQueuedThreads() { 681 return sync.getQueuedThreads(); 682 } 683 684 /** 685 * Queries whether any threads are waiting on the given condition 686 * associated with this lock. Note that because timeouts and 687 * interrupts may occur at any time, a {@code true} return does 688 * not guarantee that a future {@code signal} will awaken any 689 * threads. This method is designed primarily for use in 690 * monitoring of the system state. 691 * 692 * @param condition the condition 693 * @return {@code true} if there are any waiting threads 694 * @throws IllegalMonitorStateException if this lock is not held 695 * @throws IllegalArgumentException if the given condition is 696 * not associated with this lock 697 * @throws NullPointerException if the condition is null 698 */ 699 public boolean hasWaiters(Condition condition) { 700 if (condition == null) 701 throw new NullPointerException(); 702 if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject)) 703 throw new IllegalArgumentException("not owner"); 704 return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition); 705 } 706 707 /** 708 * Returns an estimate of the number of threads waiting on the 709 * given condition associated with this lock. Note that because 710 * timeouts and interrupts may occur at any time, the estimate 711 * serves only as an upper bound on the actual number of waiters. 712 * This method is designed for use in monitoring of the system 713 * state, not for synchronization control. 714 * 715 * @param condition the condition 716 * @return the estimated number of waiting threads 717 * @throws IllegalMonitorStateException if this lock is not held 718 * @throws IllegalArgumentException if the given condition is 719 * not associated with this lock 720 * @throws NullPointerException if the condition is null 721 */ 722 public int getWaitQueueLength(Condition condition) { 723 if (condition == null) 724 throw new NullPointerException(); 725 if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject)) 726 throw new IllegalArgumentException("not owner"); 727 return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition); 728 } 729 730 /** 731 * Returns a collection containing those threads that may be 732 * waiting on the given condition associated with this lock. 733 * Because the actual set of threads may change dynamically while 734 * constructing this result, the returned collection is only a 735 * best-effort estimate. The elements of the returned collection 736 * are in no particular order. This method is designed to 737 * facilitate construction of subclasses that provide more 738 * extensive condition monitoring facilities. 739 * 740 * @param condition the condition 741 * @return the collection of threads 742 * @throws IllegalMonitorStateException if this lock is not held 743 * @throws IllegalArgumentException if the given condition is 744 * not associated with this lock 745 * @throws NullPointerException if the condition is null 746 */ 747 protected Collection<Thread> getWaitingThreads(Condition condition) { 748 if (condition == null) 749 throw new NullPointerException(); 750 if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject)) 751 throw new IllegalArgumentException("not owner"); 752 return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition); 753 } 754 755 /** 756 * Returns a string identifying this lock, as well as its lock state. 757 * The state, in brackets, includes either the String {@code "Unlocked"} 758 * or the String {@code "Locked by"} followed by the 759 * {@linkplain Thread#getName name} of the owning thread. 760 * 761 * @return a string identifying this lock, as well as its lock state 762 */ 763 public String toString() { 764 Thread o = sync.getOwner(); 765 return super.toString() + ((o == null) ? 766 "[Unlocked]" : 767 "[Locked by thread " + o.getName() + "]"); 768 } 769 }