Reentlock主要利用CAS+AQS实现，支持公平性锁和非公平性锁

AQS使用一个先进先出的队列表示排队等待锁的线程，同时每个节点

维护一个等待状态waitStatus

基本实现原理：

当一个线程试图获取锁的时候，先通过CAS进行判断当前能否获取锁，如果不能获取锁，就进入等待队列并被挂起，当要获取的锁被释放之后，再次通过CAS尝试获取锁，此时会有两种情况，一种是公平性锁，一种是非公平性锁

公平性锁：按照在等待队列中的顺序获取锁，如果自己当前不是队首的线程，就排到队尾，由队首线程获取锁

非公平锁：无论自己是否处于队首，都会尝试获取锁，不顾及等待队列中的其他线程

非公平性锁源码实现

   final boolean nonfairTryAcquire(int acquires) {
       //获取当前线程     
       final Thread current =   Thread.currentThread();
       //获取state变量
            int c = getState();
            if (c == 0) {
                //如果当前state为0，说明没有线程占用锁，
                 //不考虑自己是不是第一个线程，直接尝试占用锁
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                如果state不为0，说明当前已经有线程占用了锁
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                更新当前state的值
                setState(nextc);
                return true;
            }
       获取锁失败
            return false;
        }

非公平锁的实现流程：

1.检测state字段是否为0，如果为0，直接尝试占用，不考虑自己是否是任务队列中的首个元素

2.如果不为0，判断当前锁是否被自己占用，如果被自己占用，那么更新state的值，表示锁重入的次数，如果两点都没有成功，获取锁失败，返回false

队列中线程获取锁的过程

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);
    }
​

释放锁的过程

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;
​

1.先计算state的值，判断是不是当前线程占用锁，如果没有占用锁，那么抛出异常，如果持有锁，判断释放之后state是否为0，若果为0则表示当前锁被释放成功，并且清空独占线程

公平性锁源码实现

protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//为0表示首次获取锁
               //判断队列中是否存在其他线程并且自己是不是第一个尝试修改当前state的值的线程
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
    //如果state不为0，判断自己是否已经获得该锁，
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

​

1.获取到当前state的值，然后判断当前等待队列中是否存在其他线程并且自己是不是第一个尝试修改当前state的值，如果成功，则返回true

2.如果state不为0，判断当前持有锁的线程是不是自己，如果是自己的话，将state+1，也就是重入状态+1，返回true

公平性锁和非公平性锁的区别

公平性锁在源码实现上可以看出在尝试修改state状态之前会先判断当前队列中的第一个线程是不是自己，而非公平性锁根本不会管当前的队列中是否存在元素，只顾自己尝试修改state的状态