多线程与高并发（五）—— 源码解析 ReentrantLock - ToB企服应用市场:ToB评测及商务社交产业平台

public class ReentrantLock implements Lock, java.io.Serializable {
abstract static class Sync extends AbstractQueuedSynchronizer {
}
static final class FairSync extends Sync {
}
static final class NonfairSync extends Sync {
}
}

复制代码

public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}

复制代码

/**
* Queries whether any threads have been waiting to acquire longer
* than the current thread.
* 查找是否有其他线程比当前线程等待了更久的时间
*
* 这个方法有点类似下面伪代码的逻辑，但是更有效
* <p>An invocation of this method is equivalent to (but may be
* more efficient than):
* <pre> {@code
* getFirstQueuedThread() != Thread.currentThread() &&
* hasQueuedThreads()}</pre>
*
* 注意由于线程可能在任何时候因为中断或者超时被取消，返回 true 并不能保证其他线程会在当前线程之前获取锁。
* 因此，其他线程也可能在当前线程返回 false 之后由于队列为空而赢得竞争去入队
* <p>Note that because cancellations due to interrupts and
* timeouts may occur at any time, a {@code true} return does not
* guarantee that some other thread will acquire before the current
* thread. Likewise, it is possible for another thread to win a
* race to enqueue after this method has returned {@code false},
* due to the queue being empty.
*
* <p>This method is designed to be used by a fair synchronizer to
* avoid <a target="_blank" href="https://www.cnblogs.com/AbstractQueuedSynchronizer#barging">barging</a>.
* Such a synchronizer's {@link #tryAcquire} method should return
* {@code false}, and its {@link #tryAcquireShared} method should
* return a negative value, if this method returns {@code true}
* (unless this is a reentrant acquire). For example, the {@code
* tryAcquire} method for a fair, reentrant, exclusive mode
* synchronizer might look like this:
*
* <pre> {@code
* protected boolean tryAcquire(int arg) {
* if (isHeldExclusively()) {
* // A reentrant acquire; increment hold count
* return true;
* } else if (hasQueuedPredecessors()) {
* return false;
* } else {
* // try to acquire normally
* }
* }}</pre>
*
* @return {@code true} if there is a queued thread preceding the
* current thread, and {@code false} if the current thread
* is at the head of the queue or the queue is empty
* 如果队列中有比当前线程处于更靠前的节点返回 true，如果当前队列为空或者当前线程为队列第一个节点返回 false
* @since 1.7
*/
public final boolean hasQueuedPredecessors() {
// 如果当前线程为队列中的第一个节点，那么正确性取决于头节点是否先于尾节点被初始化以及头节点的 next 指针是正确的
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}

复制代码

public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}

复制代码

public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

复制代码

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 如果被中断则直接抛出中断异常
if (Thread.interrupted())
throw new InterruptedException();
// 获取锁失败就执行 doAcquireNanos 入队，直到超时返回 false
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout);
}

复制代码