面试题：ReentrantLock原理

ReentrantLock是基于AQS实现的一种可重入锁
ReentrantLock就是通过重写了AQS的tryAcquire和tryRelease方法实现的lock和unlock。

AbstractQueuedSynchronizer：抽象类，AQS框架核心类，其内部以虚拟队列的方式管理线程的锁获取与锁释放，其中获取锁(tryAcquire方法)和释放锁(tryRelease方法)并没有提供默认实现，需要子类重写这两个方法实现具体逻辑，目的是使开发人员可以自由定义获取锁以及释放锁的方式。

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer{
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }
}

Sync：抽象类，是ReentrantLock的内部类，继承自AQS，实现了释放锁的操作(tryRelease()方法)，并提供了lock抽象方法，由其子类实现。

NonfairSync：是ReentrantLock的内部类，继承自Sync，非公平锁的实现类。

FairSync：是ReentrantLock的内部类，继承自Sync，公平锁的实现类。

ReentrantLock的构造方法

public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

默认是非公平锁，也可以根据有参构造根据传入的参数来创建。

ReentrantLock的Lock()方法

public void lock() {
     sync.lock();
}

去调用sync的lock方法，sync在ReentrantLock构造的时候已经被创建为公平/非公平。

对于非公平锁：

static final class NonfairSync extends Sync {
    //加锁
    final void lock() {
        if (compareAndSetState(0, 1))
          setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
}

先对state进行cas操作，如果操作成功，表明获取锁成功，把当前线程设置为独占锁线程；如果操作失败，去执行acquire（）方法

public final void acquire(int arg) {
    //再次尝试获取同步状态
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

 protected final boolean tryAcquire(int acquires) {
         return nonfairTryAcquire(acquires);
     }
 }

final boolean nonfairTryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
      int c = getState();
      if (c == 0) {
          //执行CAS操作
          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");
          setState(nextc);
          return true;
      }
      return false;
  }

获取锁步骤
如果在tryAcquire()返回false，则表示当前线程获取锁失败，执行
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法，将线程加入队列

public final void acquire(int arg) {
    //再次尝试获取同步状态
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

1.由当前线程构造一个节点。
2.若等待队列不为空时，则设置当前节点为队列尾节点。
3.若队列为空或者失败时，则重复尝试将该节点加入到队列成为尾节点。

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode); // 当前线程构造一个节点
    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) {
    for (;;) {
        Node t = tail;
        if (t == null) { // 若队列为空，则当前节点设为头节点
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t; // 若队列非空，则当前节点加入队列为尾节点
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

这个方法使用一个死循环进行CAS操作，可以解决多线程并发问题。这里做了两件事，一是如果还没有初始同步队列则创建新结点并使用compareAndSetHead设置头结点，tail也指向head，二是队列已存在，则将新结点node添加到队尾。

来自：

ReentrantLock的UnLock()方法

public void unlock() {
sync.release(1);
}

public final boolean release(int arg) {
//子类重写的tryRelease方法，需要等锁的state=0，即tryRelease返回true的时候，才会去唤醒其
//它线程进行尝试获取锁。
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}

protected final boolean tryRelease(int releases) {
//状态的state减去releases
int c = getState() - releases;
//判断锁的所有者是不是该线程
if (Thread.currentThread() != getExclusiveOwnerThread())
//如果所的所有者不是该线程 则抛出异常 也就是锁释放的前提是线程拥有这个锁，![请添加图片描述](https://img-blog.csdnimg.cn/d37253db9fac40c697b70ef1ca46eae6.png)

throw new IllegalMonitorStateException();
boolean free = false;
//如果该线程释放锁之后 状态state=0，即锁没有重入，那么直接将将锁的所有者设置成null
//并且返回true，即代表可以唤醒其他线程去获取锁了。如果该线程释放锁之后state不等于0，
//那么代表锁重入了，返回false，代表锁还未正在释放，不用去唤醒其他线程。
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}

公平锁加锁过程

ReentrantLock和Synchronized对比

1.两者都是可重入锁
“可重入锁”概念是：自己可以再次获取自己的内部锁。比如，一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁时，还可以再获取的；如果不可锁重入的话，就会造成死锁；同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时，才能最终释放锁。
2. synchronized 依赖于 JVM，而 ReentrantLock 依赖于 API，synchronized 是依赖于 JVM 实现的。ReentrantLock 是 JDK 层面实现的
3.ReentrantLock 比 synchronized 增加了一些高级功能
ReentrantLock 提供了一种能够中断等待锁线程的机制，通过 lock.lockInterruptibly() 来实现这个机制，也就是说正在等待的线程可以选择放弃等待，改为处理其他事情；
ReentrantLock 可以指定是公平锁还是非公平，而 synchronized 只能是非公平锁。所谓的公平锁，就是先等待的线程最先获得锁；ReentrantLock 默认是非公平的，可以通过 ReentrantLock 类的 ReentrantLock(boolean fair) 构造方法来制定是否是公平的；
synchronized 关键字结合 wait() 和 notify()/notifyAll() 方法使用，可以实现等待/通知机制，ReentrantLock 类则需要借助于 Condition 接口与 newCondition() 方法。
4.synchronized 遇到异常自动抛出， ReentrantLock不能，因此unlock方法要放在finally里面
5. ReentrantLock可以通过trylock判断是否持有锁
6. ReentrantLock是显示锁，synchronized隐式锁