ReentrantLock实现原理详解

void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();

private Lock lock = new ReentrantLock();
public void test(){
 lock.lock();
 try{
 doSomeThing();
 }catch (Exception e){
 // ignored
 }finally {
 lock.unlock();
 }
}

public ReentrantLock() {
 sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
 sync = fair &＃63; new FairSync() : new NonfairSync();
}

final void lock() {
 if (compareAndSetState(0, 1))
 setExclusiveOwnerThread(Thread.currentThread());
 else
 acquire(1);
}

public final void acquire(int arg) {
 if (!tryAcquire(arg) &&
 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
 selfInterrupt();
}

final boolean nonfairTryAcquire(int acquires) {
 //获取当前线程
 final Thread current = Thread.currentThread();
 //获取state变量值
 int c = getState();
 if (c == 0) { //没有线程占用锁
 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");
 // 更新state值为新的重入次数
 setState(nextc);
 return true;
 }
 //获取锁失败
 return false;
}

/**
 * 将新节点和当前线程关联并且入队列
 * @param mode 独占/共享
 * @return 新节点
 */
private Node addWaiter(Node mode) {
 //初始化节点,设置关联线程和模式(独占 or 共享)
 Node node = new Node(Thread.currentThread(), mode);
 // 获取尾节点引用
 Node pred = tail;
 // 尾节点不为空,说明队列已经初始化过
 if (pred != null) {
 node.prev = pred;
 // 设置新节点为尾节点
 if (compareAndSetTail(pred, node)) {
 pred.next = node;
 return node;
 }
 }
 // 尾节点为空,说明队列还未初始化,需要初始化head节点并入队新节点
 enq(node);
 return node;
}

/**
 * 初始化队列并且入队新节点
 */
private Node enq(final Node node) {
 //开始自旋
 for (;;) {
 Node t = tail;
 if (t == null) { // Must initialize
 // 如果tail为空,则新建一个head节点,并且tail指向head
 if (compareAndSetHead(new Node()))
 tail = head;
 } else {
 node.prev = t;
 // tail不为空,将新节点入队
 if (compareAndSetTail(t, node)) {
 t.next = node;
 return t;
 }
 }
 }
}

/**
 * 已经入队的线程尝试获取锁
 */
final boolean acquireQueued(final Node node, int arg) {
 boolean failed = true; //标记是否成功获取锁
 try {
 boolean interrupted = false; //标记线程是否被中断过
 for (;;) {
 final Node p = node.predecessor(); //获取前驱节点
 //如果前驱是head,即该结点已成老二，那么便有资格去尝试获取锁
 if (p == head && tryAcquire(arg)) {
 setHead(node); // 获取成功,将当前节点设置为head节点
 p.next = null; // 原head节点出队,在某个时间点被GC回收
 failed = false; //获取成功
 return interrupted; //返回是否被中断过
 }
 // 判断获取失败后是否可以挂起,若可以则挂起
 if (shouldParkAfterFailedAcquire(p, node) &&
  parkAndCheckInterrupt())
 // 线程若被中断,设置interrupted为true
 interrupted = true;
 }
 } finally {
 if (failed)
 cancelAcquire(node);
 }
}

/**
 * 判断当前线程获取锁失败之后是否需要挂起.
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
 //前驱节点的状态
 int ws = pred.waitStatus;
 if (ws == Node.SIGNAL)
 // 前驱节点状态为signal,返回true
 return true;
 // 前驱节点状态为CANCELLED
 if (ws > 0) {
 // 从队尾向前寻找第一个状态不为CANCELLED的节点
 do {
 node.prev = pred = pred.prev;
 } while (pred.waitStatus > 0);
 pred.next = node;
 } else {
 // 将前驱节点的状态设置为SIGNAL
 compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
 }
 return false;
} 
/**
 * 挂起当前线程,返回线程中断状态并重置
 */
private final boolean parkAndCheckInterrupt() {
 LockSupport.park(this);
 return Thread.interrupted();
}

public void unlock() {
 sync.release(1);
} 
public final boolean release(int arg) {
 if (tryRelease(arg)) {
 Node h = head;
 if (h != null && h.waitStatus != 0)
 unparkSuccessor(h);
 return true;
 }
 return false;
}

/**
 * 释放当前线程占用的锁
 * @param releases
 * @return 是否释放成功
 */
protected final boolean tryRelease(int releases) {
 // 计算释放后state值
 int c = getState() - releases;
 // 如果不是当前线程占用锁,那么抛出异常
 if (Thread.currentThread() != getExclusiveOwnerThread())
 throw new IllegalMonitorStateException();
 boolean free = false;
 if (c == 0) {
 // 锁被重入次数为0,表示释放成功
 free = true;
 // 清空独占线程
 setExclusiveOwnerThread(null);
 }
 // 更新state值
 setState(c);
 return free;
}

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();
 return tryAcquire(arg) ||
 doAcquireNanos(arg, nanosTimeout);
}

/**
 * 在有限的时间内去竞争锁
 * @return 是否获取成功
 */
private boolean doAcquireNanos(int arg, long nanosTimeout)
 throws InterruptedException {
 // 起始时间
 long lastTime = System.nanoTime();
 // 线程入队
 final Node node = addWaiter(Node.EXCLUSIVE);
 boolean failed = true;
 try {
 // 又是自旋!
 for (;;) {
 // 获取前驱节点
 final Node p = node.predecessor();
 // 如果前驱是头节点并且占用锁成功,则将当前节点变成头结点
 if (p == head && tryAcquire(arg)) {
 setHead(node);
 p.next = null; // help GC
 failed = false;
 return true;
 }
 // 如果已经超时,返回false
 if (nanosTimeout <= 0)
 return false;
 // 超时时间未到,且需要挂起
 if (shouldParkAfterFailedAcquire(p, node) &&
  nanosTimeout > spinForTimeoutThreshold)
 // 阻塞当前线程直到超时时间到期
 LockSupport.parkNanos(this, nanosTimeout);
 long now = System.nanoTime();
 // 更新nanosTimeout
 nanosTimeout -= now - lastTime;
 lastTime = now;
 if (Thread.interrupted())
 //相应中断
 throw new InterruptedException();
 }
 } finally {
 if (failed)
 cancelAcquire(node);
 }
}