AQS的原理和使用

什么是AQS

全称AbstractQueuedSynchronizer

AQS实现是基于CLH队列锁

CLH同步队列是一个FIFO双向队列，这三张图是来解释状态改变的过程，关于CLH可以自行查询

多个线程时，myPred指向上一个存储的线程，并且自循检查前一个线程是否释放锁，自循一定次数后进入阻塞状态

上一个线程的locked等于false时，当前线程就可以获取到锁。

AQS使用方式

实现见下面锁可重入示例代码

AQS的设计模式

模版模式：具体实现交给子类去实现。自己要实现同步锁，重写模版方法就可以实现。

AQS中的核心方法

tryAcquire和tryRelease方法。
AQS主要通过核心成员变量state来判断是否获取到锁。

了解ReentrantLock锁

• 锁的公平与非公平

1. 公平锁
   
2. 非公平锁
   

区别在于公平锁判断当前线程在队列中前面是否还有其他线程

• 锁的可重入

同一个加锁方法，递归调用依然可以拿到锁，不会出现卡死的情况。

1. 例子：

static final Lock lock = new ReenterSelfLock();

public void reenter(int x) {
      lock.lock();
      try {
            System.out.println(Thread.currentThread().getName()+":递归层级:"+x);
            int y = x - 1;
            if (y==0) return;
            else{
                reenter(y);
            }
        } finally {
            lock.unlock();
        }
}

public void test() {
        class Worker extends Thread {
			public void run() {
                System.out.println(Thread.currentThread().getName());
                SleepTools.second(1);
                reenter(3);
            }
        }
        // 启动3个子线程
        for (int i = 0; i < 3; i++) {
            Worker w = new Worker();
            w.start();
        }

2. 如何实现可重入锁：

/**
 *类说明：实现独占锁,可重入
 */
public class ReenterSelfLock implements Lock {
    /* 静态内部类，自定义同步器*/
    private static class Sync extends AbstractQueuedSynchronizer {

        /* 是否处于占用状态*/
        protected boolean isHeldExclusively() {
            return getState() > 0;
        }

        /* 当状态为0的时候获取锁*/
        public boolean tryAcquire(int acquires) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }else if(getExclusiveOwnerThread()==Thread.currentThread()){
                setState(getState()+1);
                return  true;
            }
            return false;
        }

        /* 释放锁，将状态设置为0*/
        protected boolean tryRelease(int releases) {
            if(getExclusiveOwnerThread()!=Thread.currentThread()){
                throw new IllegalMonitorStateException();
            }
            if (getState() == 0)
                throw new IllegalMonitorStateException();

            setState(getState()-1);
            if(getState()==0){
                setExclusiveOwnerThread(null);
            }
            return true;
        }

        /* 返回一个Condition，每个condition都包含了一个condition队列*/
        Condition newCondition() {
            return new ConditionObject();
        }
    }

    /* 仅需要将操作代理到Sync上即可*/
    private final Sync sync = new Sync();

    public void lock() {
    	System.out.println(Thread.currentThread().getName()+" ready get lock");
        sync.acquire(1);
        System.out.println(Thread.currentThread().getName()+" already got lock");
    }

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

    public void unlock() {
    	System.out.println(Thread.currentThread().getName()+" ready release lock");
        sync.release(1);
        System.out.println(Thread.currentThread().getName()+" already released lock");
    }

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

    public boolean isLocked() {
        return sync.isHeldExclusively();
    }

    public boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

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

    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
}

在AQS的tryAcquire和tryRelease方法中分别对state本身加减