Java-ReentrantLock-非公平锁源码分析

   //默认构造器 构建非公平锁
   public ReentrantLock() {
     sync = new NonfairSync();
   }
   //传值 构建 true 构建 公平锁,false 构建非公平锁     
   public ReentrantLock(boolean fair) {
     sync = fair ? new FairSync() : new NonfairSync();
   }

  // 非公平锁 为一个内部类 ,他继承 Sync 内部类
  static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;
    @Override
    final void lock() {
        //当前线程直接尝试设置state (当前语义就是获取锁)
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //如果失败执行 acquire (AQS提供独占模式)
            acquire(1);
    }
    //重写AQS tryAcquire
    @Override    
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
  }

 //抽象内部类 继承 AQS
 abstract static class Sync extends AbstractQueuedSynchronizer {

    private static final long serialVersionUID = -5965833819987602667L;
    //声明抽象方法 lock 
    abstract void lock();
    //ReentrantLock state 当前语义 0 未有线程获取锁 state > 0 代表已经存在线程占用
    //执行不公平的tryLock。
    //Try Acquire是在子类中实现的，但两者都需要对trylock方法进行不公平的尝试。
    final boolean nonfairTryAcquire(int acquires) {
        //获取当前线程
        final Thread current = Thread.currentThread();
        //获取当前状态
        int c = getState();
        //如果未有线程占用
        if (c == 0) {
          //尝试直接设置 state 状态 (这里是第二次尝试不参与AQS排队)      
          if (compareAndSetState(0,acquires)) {
            //如果设置成功 设置setExclusiveOwnerThread 为当前线程
            setExclusiveOwnerThread(current);
            return true;
          }
        }
        //这个判断就是可重入锁实现的支持
        //如果当前线程等于 getExclusiveOwnerThread ,标识线程已经获取锁
        else if (current == getExclusiveOwnerThread()) {
          //当前线程累加 acquires
          int nextc = c + acquires;
          //如果 nextc < 0 标识非法 state 状态
          if (nextc < 0) {
            throw new Error("Maximum lock count exceeded");
          }
          //设置state 由于是同一个线程操作(线程重新进入),不存在安全问题,
          //所以可以直接使用setState设置state 
          setState(nextc);
          return true;
        }
        //如果以上都没有设置成功
        //则返回失败 执行AQS排队机制
        return false;
    }
    //后续代码省略
 }

   //
   abstract static class Sync extends AbstractQueuedSynchronizer {
        //省略部分代码

        //实现tryRelease
        @Override 
        protected final boolean tryRelease(int releases) {
            //当前状态减去releases(因为存在递归)
            int c = getState() - releases;
            //如果当前线程不等于获取锁的线程 则抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();    
            boolean free = false;
            //如果状态等于0 则表示当前线程释放了锁资源
            //针对锁资源唤醒的优化 只有当前线程完全释放锁了才自行唤醒操作
            //频繁唤醒,会导致锁竞争增加,cpu资源浪费
            if (c == 0) {
                //free 设置为true,AQS代码研究是可以知道 tryRelease返回true
                //AQS会唤醒内部阻塞节点 竞争锁资源
                free = true;
                setExclusiveOwnerThread(null);
            }
            //设置状态
            setState(c);
            return free;
        }
        //省略部分代码
    }