透过 ReentrantLock 分析 AQS 的实现原理

// 如果锁可用就获得锁，如果锁不可用就阻塞直到锁释放
void lock()

// 和 lock()方法相似, 但阻塞的线程可中断，抛出 java.lang.InterruptedException异常
void lockInterruptibly() 

// 非阻塞获取锁;尝试获取锁，如果成功返回true
boolean tryLock()

// 带有超时时间的获取锁方法
boolean tryLock(long timeout, TimeUnit timeUnit) 

// 释放锁
void unlock() 

// java.util.concurrent.locks.AbstractQueuedSynchronizer 
 static final class Node {
        /** 共享模式 */
        static final Node SHARED = new Node();
        /** 独占模式 */
        static final Node EXCLUSIVE = null;

        /** 取消等待，比如线程等待超时或者被中断 */
        static final int CANCELLED =  1;
        /** 线程需要 unpark 操作来唤醒 */
        static final int SIGNAL    = -1;
        /** 线程处于 condition 等待 */
        static final int CONDITION = -2;
        /** 共享模式下使用，表示下一次共享模式获取同步状态时会被无条件传播下去 */
        static final int PROPAGATE = -3;
　　　　 // 当前线程在队列中的等待状态
        volatile int waitStatus;
        // 前驱节点
        volatile Node prev;
        // 后继节点
        volatile Node next;

        /** 获取同步状态的线程 */
        volatile Thread thread;
        // 指向下一个处于 CONDITION 的节点
        Node nextWaiter;

        // 如果是共享模式返回true
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        /** 返回前驱节点，没有就抛出NPE */
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        /** Establishes initial head or SHARED marker. */
        Node() {}

        /** 将线程构成一个 node 添加到队列中，通过调用 addWaiter 使用. */
        Node(Node nextWaiter) {
            this.nextWaiter = nextWaiter;
            U.putObject(this, THREAD, Thread.currentThread());
        }

        /** 在 condition 队列使用，通过调用 addConditionWaiter 使用. */
        Node(int waitStatus) {
　　　　　　　// 通过 unsafe 类以及对应的 Node 属性在内存中的偏移量来修改对应实例的属性值。
            U.putInt(this, WAITSTATUS, waitStatus);
            U.putObject(this, THREAD, Thread.currentThread());
        }

        /** CASes waitStatus field. */
        final boolean compareAndSetWaitStatus(int expect, int update) {
            return U.compareAndSwapInt(this, WAITSTATUS, expect, update);
        }

        /** CASes next field. */
        final boolean compareAndSetNext(Node expect, Node update) {
            return U.compareAndSwapObject(this, NEXT, expect, update);
        }

        private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
        private static final long NEXT;
        static final long PREV;
        private static final long THREAD;
        private static final long WAITSTATUS;
        static {
            try {
　　　　　　　　　//获取 Node 的属性 next 在内存中的偏移量，下面同理
                NEXT = U.objectFieldOffset
                    (Node.class.getDeclaredField("next"));
                PREV = U.objectFieldOffset
                    (Node.class.getDeclaredField("prev"));
                THREAD = U.objectFieldOffset
                    (Node.class.getDeclaredField("thread"));
                WAITSTATUS = U.objectFieldOffset
                    (Node.class.getDeclaredField("waitStatus"));
            } catch (ReflectiveOperationException e) {
                throw new Error(e);
            }
        }
    }    

　　// java.util.concurrent.locks.AbstractQueuedSynchronizer 
   // 头结点
    private transient volatile Node head;
    // 尾节点      
    private transient volatile Node tail;

// java.util.concurrent.locks.AbstractQueuedSynchronizer
private volatile int state;

// java.util.concurrent.locks.AbstractQueuedSynchronizer 
// 获取State的值
protected final int getState()

// 设置State的值
protected final void setState(int newState)

// 使用CAS方式更新State
protected final boolean compareAndSetState(int expect, int update)

// **************************Synchronized的使用方式**************************
// 1.用于代码块
synchronized (this) {}
// 2.用于对象
synchronized (object) {}
// 3.用于方法
public synchronized void test () {}
// 4.可重入
for (int i = 0; i < 100; i++) {
    synchronized (this) {}
}
// **************************ReentrantLock的使用方式**************************
public void test () throw Exception {
    // 1.初始化选择公平锁、非公平锁
    ReentrantLock lock = new ReentrantLock(true);
    // 2.可用于代码块
    lock.lock();
    try {
        try {
            // 3.支持多种加锁方式，比较灵活; 具有可重入特性
            if(lock.tryLock(100, TimeUnit.MILLISECONDS)){ }
        } finally {
            // 4.手动释放锁
            lock.unlock()
        }
    } finally {
        lock.unlock();
    }
}

    // 默认是非公平锁    
    public ReentrantLock() {
        sync = new NonfairSync();
    }

   // true 是公平锁
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

// 非公平锁
static final class NonfairSync extends Sync {

}

// 公平锁
static final class FairSync extends Sync {

} 

    
　　// java.util.concurrent.locks.ReentrantLock#NonfairSync 
　　static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        // Android-removed: @ReservedStackAccess from OpenJDK 9, not available on Android.
        // @ReservedStackAccess
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

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

  protected final boolean compareAndSetState(int expect, int update) {
        return U.compareAndSwapInt(this, STATE, expect, update);
    }

    // java.util.concurrent.locks.AbstractQueuedSynchronizer 
　　 public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

　　　　　// java.util.concurrent.locks.ReentrantLock 
　　　　  final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
　　　　　　　// c=0 说明此时没有获取没有线程占有锁
            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;
        }

    // java.util.concurrent.locks.AbstractQueuedSynchronizer 
 　　private Node addWaiter(Node mode) {
        Node node = new Node(mode);
        // 死循环
        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                // 通过unsafe 类来对 Node.prev 节点赋值
                U.putObject(node, Node.PREV, oldTail);
               // 更新 tail 节点为 node，该操作对其他线程是可见的，确保每次只有一个线程可以更新成功
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return node;
                }
            } else {
                initializeSyncQueue();
            }
        }
    }

    // cas 设置 tail 节点
    private final boolean compareAndSetTail(Node expect, Node update) {
        return U.compareAndSwapObject(this, TAIL, expect, update);
    }

    // 初始化 head 和 tail 节点
    private final void initializeSyncQueue() {
        Node h;
        if (U.compareAndSwapObject(this, HEAD, null, (h = new Node())))
            tail = h;
    }    

   // java.util.concurrent.locks.AbstractQueuedSynchronizer  
　　private Node enq(Node node) {
        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                U.putObject(node, Node.PREV, oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return oldTail;
                }
            } else {
                initializeSyncQueue();
            }
        }
    }

    final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
　　　　　　　　　 // 获取前一个节点，为空，抛出 NPE
                final Node p = node.predecessor();
　　　　　　　　　 // p==head 说明 node 是队列中的第一位，这时候还会再去获取一次锁
                if (p == head && tryAcquire(arg)) {
　　　　　　　　　　　　// 获取锁成功后，node 变成 head 节点，凡是 head 节点，其 thread 和 pre 都为空，next 保持不变。
                    setHead(node); 
                    p.next = null; // help GC
　　　　　　　　　　　　// 注意这个中断记录是在获取锁之后才会被返回的，也就是说获取锁之后，才有资格处理中断
                    return interrupted;
                }
　　　　　　　　　 // 获取锁失败，说明p为头节点且当前没有获取到锁（可能是非公平锁被抢占了）
　　　　　　　　　 // 或者是p不为头结点，这个时候就要判断当前node是否要被阻塞（被阻塞条件：前驱节点的waitStatus为-1），防止无限循环浪费资源。具体两个方法下面细细分析
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
　　　　　　　　　　　　// 说明在这个过程中发生过中断，需要补上
                    interrupted = true;
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
　　　　　// 获取头结点的节点状态 
        int ws = pred.waitStatus;
　　　　　// 当前 prev node 的线程需要被 unpark 唤醒，也就是当前 node 可以接受 park 操作
        if (ws == Node.SIGNAL)
　　　　　　  // This node has already set status asking a release to signal it, so it can safely park.
            return true;
　　　　　// 前节点处于取消状态，跳过，获取再前一个的节点状态
        if (ws > 0) {
            do {
　　　　　　　　　// 这里将取消状态的节点删除
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
　　　　　　　// 同时设置下一个节点为 node
            pred.next = node;
        } else {
　　　　　　　// 设置前任节点等待状态为 SIGNAL 
            pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
        }
        return false;
    }


    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        // 如果之前中断了，为 true,并清除中断标志
        return Thread.interrupted();
    }    

public native void unpark(Thread jthread);  
public native void park(boolean isAbsolute, long time);  

    private void cancelAcquire(Node node) {
        // Ignore if node doesn't exist
        if (node == null)
            return;

        node.thread = null;

        // 过滤掉那些被取消的节点
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // 获取过滤后的前驱节点的后继节点
        Node predNext = pred.next;

 　　　　// 把当前node的状态设置为CANCELLED 
        node.waitStatus = Node.CANCELLED;
　　　　  // 如果当前节点是尾节点，将从后往前的第一个非取消状态的节点设置为尾节点 
　　     // 如果更新成功，将tail的后继节点设置为null，更新失败，说明 node 后面还有其他节点，node 不是尾接点
        if (node == tail && compareAndSetTail(node, pred)) {
            pred.compareAndSetNext(predNext, null);
        } else {
　　　　　　  // 如果当前节点不是head的后继节点，1:判断当前节点前驱节点的是否为SIGNAL，2:如果不是，则把前驱节点设置为SINGAL看是否成功 
　　　　　　  // 如果1和2中有一个为true，再判断当前节点的线程是否为null 
            // 如果上述条件都满足，把当前节点的前驱节点的后继指针指向当前节点的后继节点
            int ws;
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL))) &&
                pred.thread != null) {
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    pred.compareAndSetNext(predNext, next);
　　　　　　　　　 // 走到这里，已经把 node 从 next 队列里面删除了,但是保留了 prev 指针
            } else {
　　　　　　　　　 // 如果当前节点是head的后继节点，或者上述条件不满足，那就唤醒当前节点的后继节点
                unparkSuccessor(node);
            }
　　　　　　　// 这里修改了 node 的next 指针，但是保证了 prev 指针的不变
            node.next = node; // help GC
        }
    }

    private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
　　　　　　　// 将传入的参数node的等待状态变为 0
            node.compareAndSetWaitStatus(ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
　　　　　　　// 从后往前寻找那些没有被取消的线程
            for (Node p = tail; p != node && p != null; p = p.prev)
                if (p.waitStatus <= 0)
                    s = p;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

　　// LockSupport 
　　public static void unpark(Thread thread) {
        if (thread != null)
            U.unpark(thread);
    }

// java.util.concurrent.locks.ReentrantLock    
　　 static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        // 加锁
        final void lock() {
            acquire(1);
        }

  　　　// 
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
　　　　　　　// 当前没有线程获取锁
            if (c == 0) {
　　　　　　　　　 // 当前线程处于 head 之后，或者队列为空，就会去调用 CAS 获取锁，否则是没有机会获取锁的
                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");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

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

   // 释放锁
   public final boolean release(int arg) {
　　　　　// 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) {
       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;
     }

// java.util.concurrent.locks.ReentrantLock

public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    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());
}

    // ReentrantLock
    public boolean tryLock() {
　　　　　// 调用的是非公平锁来抢占锁
        return sync.nonfairTryAcquire(1);
    }

    // ReentrantLock
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
　　　　  // 超过一定时间后再去获取锁
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }// AQS
　　  // 拿不到锁时，等一段时间再拿不到就退出
     private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
　　　　  // 时间 <=0 直接返回
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
　　　　　// 将当前线程加入到队列中
        final Node node = addWaiter(Node.EXCLUSIVE);
        try {
            for (;;) {
                final Node p = node.predecessor();
　　　　　　　　　　// 这里如果当前线程是第一个有效节点，直接尝试去获取锁
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return true;
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L) {
　　　　　　　　　　　　// 时间到了之后，就退出等待队列
                    cancelAcquire(node);
                    return false;
                }
　　　　　　　　　　// 需要等待，并且时长大于 1000L
                if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
　　　　　　　　　　　　// 阻塞一定时间，再去获取锁
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

    // ReentrantLock     
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    // AQS
    public final void acquireInterruptibly(int arg)
            throws InterruptedException {
　　　　　// 如果发生了中断，就抛出中断异常
        if (Thread.interrupted())
            throw new InterruptedException();
　　　　　// 
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }

    // 可中断的  
    private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        try {
            for (;;) {
                final Node p = node.predecessor();
　　　　　　　　　 // 再次看能不能获取锁
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return;
                }
　　　　　　　　　 // park 前发现中断了，抛出中断错误
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }