多线程基础学习十一：AbstractQueuedSynchronizer了解

上一片学习了Lock顶级接口，现在学习一下队列同步器AbstractQueuedSynchronizer，也就是网上常看到AQS。

AbstractQueuedSynchronizer

目前我看到的Lock的实现最终都是通过AQS同步器来实现同步，所以了解这个类对了解Lock的实现有很大的帮助。

这个类提供了很多方法：

根据源码注释，非常容易理解到，这个类提供了和lock类似功能的方法。
比如这一组方法（独占锁）：
- acquire(int) 获取锁
- acquireInterruptibly(int) 获取锁并响应中断
- tryAcquireNanos(int, long) 持续一段时间获取锁，获取到返回true，获取不到或者超时返回false
- release(int) 释放锁
还有一组（共享锁）：
- acquireShared(int) 获取锁
- acquireSharedInterruptibly(int) 获取锁并响应中断
- tryAcquireSharedNanos(int, long) 持续一段时间获取锁，获取到返回true，获取不到或者超时返回false
- releaseShared(int) 释放锁

ps：独占锁和共享锁，后面再详细了解

唯一和Lock接口有区别的是获取锁和释放锁的调用，多了一个int参数，这个参数的意义是什么？

源码注释：

arg the acquire argument.  This value is conveyed to
     *        {@link #tryAcquire} but is otherwise uninterpreted and
     *        can represent anything you like

注释上说这个参数是给tryAcquire方法使用的，可以代表你喜欢的任何东西。

可以还是无法理解这个参数的意义，希望以后了解的多了，能够理解这个参数，当然如果有大神看到我这篇了解AQS的博客，能在评论里指点一下。

基本使用

这个类是一个抽象类，抽象类是没法直接使用的，所以注释里给了最常用的使用方式。

常用使用方式：

public class Mutex implements Lock{

    private static class Sync extends AbstractQueuedLongSynchronizer {

        @Override
        protected boolean tryAcquire (long arg) {

            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }

            return false;
        }

        @Override
        protected boolean tryRelease (long arg) {

            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            } else {
                setExclusiveOwnerThread(null);
            }

            setState(0);
            return true;
        }

        @Override
        protected boolean isHeldExclusively () {
            return getState() == 1;
        }

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


    private final Sync sync = new Sync();

    @Override
    public void lock () {
        sync.acquire(1);
    }

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

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

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

    @Override
    public void unlock () {
        sync.tryRelease(1);
    }

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

在常用的使用方式中，类实现了Lock接口，类中有一个内部类继承了AQS，把操作锁的方法都委托给了内部类来实现。

比如最常用的ReentranLock就是这种实现方式。

网上有很多关于AQS的实现原理的，都是很好的文章，以后有需要再看。