Java并发编程-AQS

1.什么是AQS

AQSjava.util.concurrent.locks.AbstractQueuedSynchronizer抽象队列同步器 ，是用来构建锁或者其他同步组件的基础框架。它使用了一个 int 成员变量表示同步状态，通过内置的 FIFO(先进先出) 队列来完成资源获取线程的排队工作。

使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们经常用到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。

AQS 自身没有实现任何同步接口，它仅仅是定义了若干同步状态获取和释放的方法来自定义同步组件使用，同步器既可以支持独占式地获取同步状态，也可以支持共享式地获取同步状态，这样就可以方便实现不同类型的同步组件。

AQS的设计基于模板方法模式。模板方法模式的意图是，定义一个操作中的算法的骨架，而将一些步骤的实现延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

2.修改同步状态的方法

AQS 的主要使用方式是继承，子类通过继承 AQS 并实现它的抽象方法来管理同步状态，在 AQS 里由一个 int 型的 state 来代表这个状态，在抽象方法的实现过程中免不了要对同步状态进行更改，重写同步器指定的方法时，需要使用同步器提供的如下 3 个方法来访问或修改同步状态：
getState() 获取当前同步状态
setState(intnewState) 设置当前同步状态。
compareAndSetState(int expect,int update) 使用 CAS 设置当前状态，该方法能够保证状态设置的原子性。

3.模板方法

void acquire(int arg)
独占锁获取同步状态，如果当前线程获取同步状态成功，则由该方法返回。否则，将会进入同步队列等待，该方法会调用重写的 tryAcquire(int arg)。

void acquireInterruptibly(int arg)
与acquire(int arg) 相同，但是该方法响应中断，当前线程为获取到同步状态而进入同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException并返回。

boolean tryAcquireNanos(int arg, long nanosTimeout)
在acquireInterruptibly(int arg)基础上增加了超时限制，如果当前线程在超时时间内没有获取到同步状态，那么将返回false，如果获取到了返回true。

void acquireShared(int arg)
共享式的获取同步状态，如果当前线程未获取到同步状态，将会进入同步队里等待，与独占式获取的主要区别是在同一时刻可以有多个线程获取到同步状态。

void acquireSharedInterruptibly(int arg)
与acquireShared(int arg)相同，该方法响应中断。

boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
在acquireSharedInterruptibly(int arg)基础上增加了超时限制。

boolean release(int arg)
独占式的释放同步状态，该方法会在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒。

boolean releaseShared(int arg)
共享式的释放同步状态。

Collection<Thread> getQueuedThreads()
获取等待在同步队列上的线程集合。

这些模板方法同步器提供的模板方法基本上分为 3 类：独占式获取与释放同步状态、共享式获取与释放、同步状态和查询同步队列中的等待线程情况。

4.可重写的方法

protected boolean tryAcquire(int arg)
独占式获取同步状态，实现该方法需要查询当前状态并判断同步状态是否符合预期，然后再进行CAS设置同步状态。

protected boolean tryRelease(int arg)
独占式的同步状态，等待获取同步状态得线程将有机会获取同步状态。

protected int tryAcquireShared(int arg)
共享式获取同步状态，返回大于等于0的值，表示获取成功，反之，获取失败。

protected boolean tryReleaseShared(int arg)
共享式释放同步状态

protected boolean isHeldExclusively()
当前同步状态是否在独占模式下被占用，一般方法表示是否被当前所线程独占。

5.AQS 的基础原理-CLH 队列锁

CLH 队列锁即 Craig, Landin, and Hagersten (CLH) locks。(这是三个人的名字）
CLH 队列锁也是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程仅仅在本地变量上自旋，它不断轮询前驱的状态，假设发现前驱释放了锁就结束自旋。
当一个线程需要获取锁时：

1. 创建一个的QNode，将其中的locked设置为true表示需要获取锁，myPred表示对其前驱结点的引用。
   
2. 线程 A 对 tail 域调用 getAndSet 方法，使自己成为队列的尾部，同时获取
   一个指向其前驱结点的引用 myPred
   
   线程 B 需要获得锁，同样的流程再来一遍
   
3. 线程就在前驱结点的 locked 字段上旋转，直到前驱结点释放锁(前驱节点 的锁值 locked == false)
4. 当一个线程需要释放锁时，将当前结点的 locked 域设置为 false，同时回收 前驱结点
   
   如上图所示，前驱结点释放锁，线程 A 的 myPred 所指向的前驱结点的 locked
   字段变为 false，线程 A 就可以获取到锁。CLH 队列锁的优点是空间复杂度低（如果有 n 个线程，L 个锁，每个线程每次只获取一个锁，那么需要的存储空间是 O（L+n），n 个线程有 n 个 myNode，L个锁有 L 个 tail）。CLH 队列锁常用在 SMP 体系结构下。
   Java 中的 AQS 是 CLH 队列锁的一种变体实现。

6.实现一个自己的独占锁

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 *类说明：实现一个自己的独占锁
 */
public class SelfLock implements Lock {

    /*静态内部类，自定义同步器*/
    private static class Sync extends AbstractQueuedSynchronizer{

        /*是否处于占用状态*/
        @Override
        protected boolean isHeldExclusively() {
            return getState()==1;
        }

        /*获取锁*/
        @Override
        protected boolean tryAcquire(int arg) {
            if(compareAndSetState(0,1)){
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        /*释放*/
        @Override
        protected boolean tryRelease(int arg) {
            if(getState()==0){
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        Condition newCondition(){
            return new ConditionObject();
        }
    }

    private final Sync sync = new Sync();

    @Override
    public void lock() {
        System.out.println(Thread.currentThread().getName()+" 准备获取锁!");
        sync.acquire(1);
        System.out.println(Thread.currentThread().getName()+" 已经获取到锁!");
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit){
        return false;
    }

    @Override
    public void unlock() {
        System.out.println(Thread.currentThread().getName()+" 准备释放锁!");
        sync.release(1);
        System.out.println(Thread.currentThread().getName()+" 已经释放了锁!");
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }


}