AQS的原理

    AQS: AbstractQueuedSynchronizer的简称，在jdk中，我们可以发现，这是一个抽象类，需要我们实现tryAcquire和tryRelease方法。是我们可以自己实现锁的一种方式。

1.使用方法

• 自定义Sync类，继承自AbstractQueuedSynchronizer,实现其tryAcquire()和tryRelease()方法。
• 自定义MyLock类，继承自Lock，实现其相应的方法，重要的是lock与unLock方法，在这两个方法中，分别调用Sync.acquire()与Sync.release方法。在AQS类内部,acquire会调用tryAcquire，release会调用tryRelease方法。
• 在需要锁的地方，使用MyLock.lock及MyLock.unLock来实现锁的添加和消除。而Sync类，则做为MyLock的内部类来调用，不被外界使用

2.原理
    以下我们会以ReentrantLock为例来讲解，先看AbstractQueueSynchronizer类：

AbstractQueuedSynchronizer.java
    private transient volatile AbstractQueuedSynchronizer.Node head;
    private transient volatile AbstractQueuedSynchronizer.Node tail;
    private volatile int state;
    protected final int getState() {
        return this.state;
    }

    protected final void setState(int var1) {
        this.state = var1;
    }

    protected final boolean compareAndSetState(int var1, int var2) {
        return unsafe.compareAndSwapInt(this, stateOffset, var1, var2);
    }

    通过上述代码，需要注意关键的点：变量state及方法compareAndSetState,通过这两个定义，我们可以推出，AQS内部锁机制，实际还是通过CAS机制来进行的。

我们查看ReentrantLock.FairSync的代码

FairSync extends ReentrantLock.Sync
        protected final boolean tryAcquire(int var1) {
            Thread var2 = Thread.currentThread();
            int var3 = this.getState();
            if (var3 == 0) {
                if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, var1)) {
                    this.setExclusiveOwnerThread(var2);
                    return true;
                }
            } else if (var2 == this.getExclusiveOwnerThread()) {
                int var4 = var3 + var1;
                if (var4 < 0) {
                    throw new Error("Maximum lock count exceeded");
                }

                this.setState(var4);
                return true;
            }

            return false;
        }

通过代码可以看出，在ReentrantLock中，其lock的实现，就是用到了AbstractQueuedSynchronizer提供的compareAndSetState,即CAS的原理。所以在理解AQS的时候，一定要知道其内部state的作用。

3.AQS的队列(CLH队列)
对于已获得锁的线程可以去执行了，但对于未获得锁的线程如何处理呢，这就要用到AQS中的Q了，从上面的代码中，我们可以看到 ** AbstractQueuedSynchronizer.Node**，这就是AQS中保存的队列，申请所失败的线程，会加到队列当中，并且从代码中可以看出，队列中的结点会保存自己的前驱及后驱节点。

AbstractQueueSynchronizer.java
    public final void acquire(int var1) {
        if (!this.tryAcquire(var1) && this.acquireQueued(this.addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE), var1)) {
            selfInterrupt();
        }
    }
    final boolean acquireQueued(AbstractQueuedSynchronizer.Node var1, int var2) {
        boolean var3 = true;

        try {
            boolean var4 = false;

            while(true) {
                AbstractQueuedSynchronizer.Node var5 = var1.predecessor();
                if (var5 == this.head && this.tryAcquire(var2)) {
                    this.setHead(var1);
                    var5.next = null;
                    var3 = false;
                    boolean var6 = var4;
                    return var6;
                }

                if (shouldParkAfterFailedAcquire(var5, var1) && this.parkAndCheckInterrupt()) {
                    var4 = true;
                }
            }
        } finally {
            if (var3) {
                this.cancelAcquire(var1);
            }

        }
    }

在tryAcquire()拿锁时，如果失败了，会调用acquireQueued方法，将线程添加到队列中。
(在有的资料中，说Node添加到队列后，会进行自旋，检查自己的上一节点是否已释放锁，但检查几次后，就会停止检查，这个我还有点没明白，后续补充一下)

4.公平锁与非公平锁
    在使用ReentrantLock时，其构造方法中可以传入一个boolean类型数据，来表明是否为公平锁，那什么是公平锁与非公平锁
公平锁：多线程按照申请锁的顺序来获取锁，不会出现争抢的情况。
非公平锁：多线程不会按照顺序获取锁，会先尝试去争抢锁，有可能后申请的线程比先申请的线程先抢到锁，在高并发情况下，可能会造成优先级反转和饥饿的现象。
ReentrantLock默认为非公平锁，也可指定boolean值，改为公平锁，具体公平与非公平的实现，还要比较其NonfairSync与FairSync的实现

static final class FairSync extends ReentrantLock.Sync {
        protected final boolean tryAcquire(int var1) {
            Thread var2 = Thread.currentThread();
            int var3 = this.getState();
            if (var3 == 0) {
                if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, var1)) {
                    this.setExclusiveOwnerThread(var2);
                    return true;
                }
            } else if (var2 == this.getExclusiveOwnerThread()) {
                int var4 = var3 + var1;
                if (var4 < 0) {
                    throw new Error("Maximum lock count exceeded");
                }

                this.setState(var4);
                return true;
            }
            return false;
        }
    }


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

        protected final boolean tryAcquire(int var1) {
            return this.nonfairTryAcquire(var1);
        }
    }

比较其tryAquire方法后，两者最大的区别在于!this.hasQueuedPredecessors()，在公平锁中，调用了此方法，而在非公平锁中，则没有。在此方法中，会判断线程的前驱结点线程是否在队列前面，如果是，就去尝试获取锁，达到队列前面的线程能优先获取锁，从而实现公平锁。而在非公平锁中，则不会检查此项，每个结点都会尝试拿锁，但最后不一定是最先入队的拿到锁。

5.可重入锁
    广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。我们所知的ReentransLock和Synchronized.看源码，了解ReentransLock如何实现可重入的：

FairSync.java
 protected final boolean tryAcquire(int var1) {
            Thread var2 = Thread.currentThread();
            int var3 = this.getState();
            if (var3 == 0) {
                if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, var1)) {
                    this.setExclusiveOwnerThread(var2);
                    return true;
                }
            //可重入机制的关键
            } else if (var2 == this.getExclusiveOwnerThread()) {
                int var4 = var3 + var1;
                if (var4 < 0) {
                    throw new Error("Maximum lock count exceeded");
                }

                this.setState(var4);
                return true;
            }

            return false;
        }

关键代码：var2 == this.getExclusiveOwnerThread(),通过上面，我们知道，在AQS中，通过state字段是否为0来进行CAS操作的，如果当前线程存在递归，第一次获取锁之后，state的值必然会变为了1，但递归仍在此线程中，就会再进行到此处加锁的代码，此时如果再进行CAS操作，就必然是拿锁失败，则会走到上面标粗的关键代码上，此时我们只要判断当前线程是之前拿到锁的线程，则让state++，接着往下处理即可。否则，会出现死锁的现象。