【Java并发锁】AbstractQueuedSynchronizer接口与示例

目录

1 前言

2 接口方法

3 自定义同步器

---

1 前言

本人jdk版本8。

队列同步器AbstractQueuedSynchronizer(以下简称同步器)，是用来构建锁或者其他同步组件的基础框架，它使用了一个int成员变量来表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作，并发包的作者（doug Lea）期望他能够称为实现大部分同步需求的基础。

同步器是实现锁（也可以是任意同步组件）的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。同步器提供了共享式和独占式获取锁、释放锁的模板方法，也提供了对同步状态、阻塞队列的操作和查询方法，锁的定义者只需要实现同步器指定的特定方法即可。可以这样理解二者之间的关系：锁是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程并行访问），隐藏了实现细节；同步器面向的是锁的实现者，他简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒的底层操作。锁和同步器很好地隔离了使用者和实现者所需关注的领域。

2 接口方法

要想使用这个类来创建自己的同步器，必须要重写下面5个方法：

重写同步器指定的方法时，需要使用同步器提供的的如下3个方法来访问或修改同步状态：

• getState()：获取当前同步值。
• setState(int newState)：设置当前同步值。
• compareAndSetState(int expect,int update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性。

同时，同步器也提供了实现好的模板方法，当实现自定义同步组件时，可以调用这些模板方法，部分模板方法如下表所示。

同步器提供的模板方法基本上分为3类：独占式获取与释放同步状态、共享式获取与释放同步状态和查询同步队列中的等待线程情况。自定义同步组件将使用同步器提供的模板方法来实现自己的同步语义

3 自定义同步器

顾名思义，独占锁就是在同一时刻只能有一个线程获取到锁，而其它获取锁的线程只能处于同步队列中等待，只有获取锁的线程释放了锁，后继的线程才能够获取锁。下面是官方提供的自定义独占锁的例子，在Mutex的实现中，以获取锁的lock()方法为例，只需要在方法实现中调用同步器的模板方法Acqurie(int acqurie)即可。

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

        //是否处于占用状态
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        //当状态为0的时候获取锁
        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0,1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        //释放锁，将状态设置为0

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

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

    //仅需要将操作代理到Sync上即可
    private final Sync sync = new Sync();
    @Override
    public void lock() {sync.tryAcquire(1);}
    @Override
    public boolean tryLock() {return sync.tryAcquire(1);}
    @Override
    public void unlock() {sync.tryRelease(1);}
    @Override
    public Condition newCondition() {return sync.newCondition();}
    public boolean isLocked() {return sync.isHeldExclusively();}
    public boolean hasQueuedThreads() {return sync.hasQueuedThreads();}
    @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));
    }
}