ReentrantLock源码分析

简单使用

public class ReentrantLockDemo {
  private static Lock lock = new ReentrantLock();
  
  public static void main(String[] args) {
    lock.lock();
    try {
      //do somethings
    } finally {
      lock.unlock();
    }
  }
}

分析： 使用lock.lock()方法，会获取当前锁的对象，lock.unlock()会释放锁对象。

底层源码分析

ReentrantLock实现互斥锁主要是依赖内部的AbstractQueueSynchronized工具类来完成线程同步的功能。

具体源码

争抢锁的过程

以NonFairSync非公平锁为例。

final void lock() {
  //这里首先根据CAS设置当前的state，期望是0，设置为1
  //state保存的是当前锁的状态0表示没有线程获取锁，1表示有线程获
  //取当前锁,大于1表示重入
  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();
}

这里的代码表示如果tryAcquire方法尝试获取锁失败，那么就调用acquireQueued方法将当前线程加入到同步队列中。其中tryAcquire方法如下。

protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
  //这里表示当前state=0，没有线程获取锁，当前线程可以直接获取锁
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
    //这里表示如果独占锁与当前线程一样，则state会+1，即重入
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

再看addWaiter方法之前，先要介绍一下，AQS中维护的双向链表队列每一个元素都是一个Node节点，节点中保存了当前线程thread下一个节点next,前一个节点prev以及当前的等待状态waitStatus,waitStatus有以下几种状态

CANCELLED = 1 表示取消
SIGNAL = -1 标记当前的节点保存的线程需要unpark
CONDITION = -2 表示当前节点所在线程在Condition队列中
PROPAGATE = -3共享模式下，该状态的线程处于可运行状态

addWaiter(Node.EXCLUSIVE)的具体实现

//当前方法会创建一个节点并加入到AQS队列中
private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
  //tail指向同步队列的最后一个node，这里第一次为空，会走enq方法,当有其他线程再次竞争锁的时候，会通过下面的代码添加到队列中，并且更新tail为新的node
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

private Node enq(final Node node) {
  //死循环，会遍历2次，一次初始化，一次设置第一个node的next，prev属性
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
              //第一次t为空，将head设置为一个新的node，不包含thread的node
                if (compareAndSetHead(new Node()))
                  //把队列的tail也设置成node
                    tail = head;
            } else {
              //此时队列为空，将新加入的node的prev设置为tail
                node.prev = t;
              //通过CAS设置队列的tail为当前node
                if (compareAndSetTail(t, node)) {
                  //设置tail的下一个节点也为node
                    t.next = node;
                    return t;
                }
            }
        }
    }

addWaiter方法执行完成后，再调用acquireQueued方法去竞争锁

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
          //死循环，只有当当前线程的prev是head，也就是自己是队列中的第一个node，且争抢到锁之后才会退出
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
              //shouldParkAfterFailedAcquire
              //判断是否要在获取锁失败之后挂起锁，主要是通过
              //CAS将当前节点的前置节点的wait设置为SIGNAL
              //parkAndCheckInterrupt方法调用
              //LockSupport.park()方法将当前线程挂起，
              //并且返回当前线程是否被中断的标记，如果被中断
              //了，则会在上面的acquire方法中调用
              //selfInterrupt()方法,重新将线程设置为可中
              //断的状态，这里主要是因为被挂起的线程不能响应中
                             //断，所以要记录下来，并且在被唤醒的时候重新设
              //置
                if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

下面来看一下释放锁的过程

lock.unlock方法内部调ReentrantLock中AQS的release()方法

public final boolean release(int arg) {
  //如果当前线程只重入一次，tryRelease会返回true
  if (tryRelease(arg)) {
    Node h = head;
    //如果head不为空，且head的waitStatus=SIGNAL（在前面
    //shouldParkAfterFailedAcquire方法中设置了）
    //unparkSuccessor解锁继任者（head指向的node）
    //内部主要调用LockSupport.unpark(s.thread)方法
    if (h != null && h.waitStatus != 0)
      unparkSuccessor(h);
    return true;
  }
  return false;
}
protected final boolean tryRelease(int releases) {
  int c = getState() - releases;
  if (Thread.currentThread() != getExclusiveOwnerThread())
    throw new IllegalMonitorStateException();
  boolean free = false;
  if (c == 0) {
    free = true;
    //将当前的独占锁置为空
    setExclusiveOwnerThread(null);
  }
  setState(c);
  return free;
}

unparkSuccessor()方法把当前处在队列的第一个节点所包含的thread唤醒，那么这个线程会继续执行acquireQueued中的死循环，通过CAS获取锁。

到此整个流程就结束了。

ReentrantLock源码分析