ReentrantLock源码分析

ReentrantLock的源码分析
abstract static class Sync extends AbstractQueuedSynchronizer
static final class FairSync extends Sync
static final class NonfairSync extends Sync
ReentrantLock具体实现委托给内部类（Sync、FairSync、NonFairSync）
公平锁个非公平锁的父类Sync:

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
        //加锁操作，抽象方法，需要子类FairSync和NonFairSync实现
        abstract void lock();
        //非公平锁和公平锁都需要调用的方法
        final boolean nonfairTryAcquire(int acquires) {
            //获取当前的线程
            final Thread current = Thread.currentThread();
            //获取AQS中state属性值， state = 0：锁空闲， 大于0：锁占用 小于0：锁溢出
            int c = getState();
            if (c == 0) { //state== 0 表示锁空闲
                //通过CAS确保多线程并发操作的安全
                if (compareAndSetState(0, acquires)) {//加锁成功
                    //设置当前持有锁的线程
                    setExclusiveOwnerThread(current);
                    return true; //获取锁成功，返回
                }
            } 
            //和if相对应的是锁非空闲：当前线程持有锁和其他线程持有锁
            else if (current == getExclusiveOwnerThread()) {//当前线程要获取锁
                //对持有锁的次数进行变更（+1）
                int nextc = c + acquires;
                //state是int类型值，有符号的类型  最高位是符号为 1：负数  0：整数
                if (nextc < 0) // overflow //被锁次数上溢（很少出现）
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);//当前持有锁的线程变更锁保护的资源
                //当前线程是持有锁的线程，获取锁成功， 返回
                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;
                //c==0，真正释放锁，将持有锁的线程信息置为null
                setExclusiveOwnerThread(null);
            }
            //变更锁的状态
            setState(c);
            //当释放锁是 ，c==0时真正释放锁，c不等于0，只是将锁状态变更，不会真释放锁
            return free;
        }
       //释放当前线程持有锁
        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
        //获取Condition对象
        final ConditionObject newCondition() {
            return new ConditionObject();
        }
        //获取持有锁的线程
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }
         //加锁次数  
         final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }
        //释放加锁，通过state判断加锁
        final boolean isLocked() {
            return getState() != 0;
        }
    }

公平锁的实现：FairSync

 static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        final void lock() {
            acquire(1);
        }
       //公平锁实现的tryAcquire
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//锁是空闲的
                //当前线程处于等待队列的第一个等待着或者等待队列为空时，当前的线程才能获取锁
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current); //加锁成功
                    return true;
                }
            }
            //当前线程正是锁的持有者
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                //变更state值
                setState(nextc);
                return true;
            }
            return false;
        }
    }

AQS类中方法：

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            //获取锁失败时，当前线程加入到等待队列
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
    
//当前线程是否处于对队列第一个或者是当前队列为null
 public final boolean hasQueuedPredecessors() {
        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());
    }

非公平性锁：NonFairSync

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        //lock加锁操作
        final void lock() {
            if (compareAndSetState(0, 1)) //直接通过CAS抢锁，true：抢锁成功
                setExclusiveOwnerThread(Thread.currentThread());//设置锁的持有者
            else
                acquire(1); //获取锁失败，进入到常规流程，acquire会首先调用tryAcquire
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

AQS的：

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

重入锁的实现：
1、重入锁（ReenTrantLock）的实现内部包含Sync、NonFairSync、FairSync内部类
2、重入锁实现重入计数使用AQS色state属性，state大于0表示锁被占用，等于0表示锁空闲，小于0计数太多导致溢出
3、重入锁必须持有对锁持有者的引用，一次判断是否可以重入

ReenTrantLock基础请看上一篇博文
本人才疏学浅，如有错误，烦请指出，谢谢！