public long convert(long d, TimeUnit u) {
return u.toNanos(d);
}
/**
* 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));
}
