/** * Acquires the lock if it is not held by another thread within the given waiting time and the * current thread has not been {@link Thread#interrupt interrupted}. * * <p>Acquires the lock if it is not held by another thread and returns immediately with the value * <tt>true</tt>, setting the lock hold count to one. If this lock has been set to use a fair * ordering policy then an available lock <em>will not</em> be acquired if any other threads are * waiting for the lock. This is in contrast to the {@link #tryLock()} method. If you want a timed * <tt>tryLock</tt> that does permit barging on a fair lock then combine the timed and un-timed * forms together: * * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... } * </pre> * * <p>If the current thread already holds this lock then the hold count is incremented by one and * the method returns <tt>true</tt>. * * <p>If the lock is held by another thread then the current thread becomes disabled for thread * scheduling purposes and lies dormant until one of three things happens: * * <ul> * <li>The lock is acquired by the current thread; or * <li>Some other thread {@link Thread#interrupt interrupts} the current thread; or * <li>The specified waiting time elapses * </ul> * * <p>If the lock is acquired then the value <tt>true</tt> is returned and the lock hold count is * set to one. * * <p>If the current thread: * * <ul> * <li>has its interrupted status set on entry to this method; or * <li>is {@link Thread#interrupt interrupted} while acquiring the lock, * </ul> * * then {@link InterruptedException} is thrown and the current thread's interrupted status is * cleared. * * <p>If the specified waiting time elapses then the value <tt>false</tt> is returned. If the time * is less than or equal to zero, the method will not wait at all. * * <p>In this implementation, as this method is an explicit interruption point, preference is * given to responding to the interrupt over normal or reentrant acquisition of the lock, and over * reporting the elapse of the waiting time. * * @param timeout the time to wait for the lock * @param unit the time unit of the timeout argument * @return <tt>true</tt> if the lock was free and was acquired by the current thread, or the lock * was already held by the current thread; and <tt>false</tt> if the waiting time elapsed * before the lock could be acquired. * @throws InterruptedException if the current thread is interrupted * @throws NullPointerException if unit is null */ public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryLock(unit.toNanos(timeout)); }
/** * Acquires the lock only if it is not held by another thread at the time of invocation. * * <p>Acquires the lock if it is not held by another thread and returns immediately with the value * <tt>true</tt>, setting the lock hold count to one. Even when this lock has been set to use a * fair ordering policy, a call to <tt>tryLock()</tt> <em>will</em> immediately acquire the lock * if it is available, whether or not other threads are currently waiting for the lock. This * "barging" behavior can be useful in certain circumstances, even though it breaks * fairness. If you want to honor the fairness setting for this lock, then use {@link * #tryLock(long, TimeUnit) tryLock(0, TimeUnit.SECONDS) } which is almost equivalent (it also * detects interruption). * * <p>If the current thread already holds this lock then the hold count is incremented by one and * the method returns <tt>true</tt>. * * <p>If the lock is held by another thread then this method will return immediately with the * value <tt>false</tt>. * * @return <tt>true</tt> if the lock was free and was acquired by the current thread, or the lock * was already held by the current thread; and <tt>false</tt> otherwise. */ public boolean tryLock() { return sync.tryLock(); }