Java并发框架——AQS之怎样使用AQS构建同步器

AQS的设计思想是通过继承的方式提供一个模板让大家能够非常easy依据不同场景实现一个富有个性化的同步器。同步器的核心是要管理一个共享状态，通过对状态的控制即能够实现不同的锁机制。

AQS的设计必须考虑把复杂反复且easy出错的队列管理工作统一抽象出来管理，而且要统一控制好流程，而暴露给子类调用的方法主要就是操作共享状态的方法，以此提供对状态的原子性操作。一般子类的同步器中使用AQS提供的getState、setState、compareAndSetState三个方法，前两个为普通的get和set方法，要使用这两个方法必需要保证不存在数据竞争，compareAndSetState方法提供了CAS方式的硬件级别的原子更新。

对于独占模式而言。锁获取与释放的流程的定义则交给acquire和release两个方法，它们定义了锁获取与释放的逻辑。同一时候也是提供给子类获取和释放锁的接口。它的运行逻辑能够參考前面的“锁的获取与释放”。它提供了一个如何强大的模板？由以下的伪代码能够清晰展示出来。请注意tryAcquire和tryRelease这两个方法，它就是留给子类实现个性化的方法，通过这两个方法对共享状态的管理能够自己定义多种多样的同步器。而队列的管理及流程的控制则不是你需要考虑的问题。

① 锁获取模板

if(tryAcquire(arg)) {

    创建node

    使用CAS方式把node插入到队列尾部

    while(true){

    if(tryAcquire(arg) 而且 node的前驱节点为头节点){

把当前节点设置为头节点

    跳出循环

}else{

    使用CAS方式改动node前驱节点的waitStatus标识为signal

    if(改动成功)

        挂起当前线程 

}

}

② 锁释放模板

    if(tryRelease(arg)){

唤醒兴许节点包括的线程

}





我们能够觉得同步器可实现不论什么不同锁的语义。一般提供给使用者的锁是用AQS框架封装实现的更高层次的实现，提供一种更加形象的API让使用者使用起来更加方便简洁。而不是让使用者直接接触AQS框架，比如。ReentrantLock、Semphore、CountDownLatch等等。这些不同的形象的锁让你使用起来更好理解更加得心应手，并且不easy混淆。

然而这些锁都是由AQS实现。AQS同步器面向的是线程和状态的控制，定义了线程获取状态的机制及线程排队等操作，非常好地隔离了两者的关注点，高层关注的是场景的使用，而AQS同步器则关心的是并发的控制。

假如你要实现一个自己定义同步装置，官方推荐的做法是将集成AQS同步器的子类作为同步装置的内部类，而同步装置中相关的操作仅仅需代理成子类中相应的方法就可以。往下用一个简单的样例看看怎样实现自己的锁，因为同步器被分为两种模式。独占模式和共享模式。所以样例也相应给出。





① 独占模式。独占模式採取的样例是银行服务窗体，假如某个银行网点仅仅有一个服务窗体，那么此银行服务窗体仅仅能同一时候服务一个人。其它人必须排队等待，所以这样的银行窗体同步装置是一个独占模型。

第一个类是银行窗体同步装置类。它依照推荐的做法使用一个继承AQS同步器的子类实现，并作为子类出现。第二个类是測试类，形象一点地说。有三位良民到银行去办理业务，各自是tom、jim和jay，我们使用BankServiceWindow就能够约束他们排队，一个一个轮着办理业务而避免陷入混乱的局面。

public class BankServiceWindow {

private final Sync sync;

public BankServiceWindow() {

sync = new Sync();

}

private static class Sync extends AbstractQueuedSynchronizer {

public boolean tryAcquire(int acquires) {

if (compareAndSetState(0, 1)) {

setExclusiveOwnerThread(Thread.currentThread());

return true;

}

return false;

}

protected boolean tryRelease(int releases) {

if (getState() == 0)

throw new IllegalMonitorStateException();

setExclusiveOwnerThread(null);

setState(0);

return true;

}

}

public void handle() {

sync.acquire(1);

}

public void unhandle() {

sync.release(1);

}

}





public class BankServiceWindowTest {

   public static void main(String[] args){

   final BankServiceWindow bankServiceWindow=new BankServiceWindow();

   Thread tom=new Thread(){

   public void run(){

   bankServiceWindow.handle();

   System.out.println("tom開始办理业务");

   try {

   this.sleep(5000);

   } catch (InterruptedException e) {

   e.printStackTrace();

   }

   System.out.println("tom结束办理业务");

   bankServiceWindow.unhandle();

   }

   };

   Thread jim=new Thread(){

   public void run(){

   bankServiceWindow.handle();

   System.out.println("jim開始办理业务");

   try {

   this.sleep(5000);

   } catch (InterruptedException e) {

   e.printStackTrace();

   }

   System.out.println("jim结束办理业务");

   bankServiceWindow.unhandle();

   }

   };

   Thread jay=new Thread(){

   public void run(){

   bankServiceWindow.handle();

   System.out.println("jay開始办理业务");

   try {

   this.sleep(5000);

   } catch (InterruptedException e) {

   e.printStackTrace();

   }

   System.out.println("jay结束办理业务");

   bankServiceWindow.unhandle();

   }

   };

   tom.start();

   jim.start();

   jay.start();

    }

}

输出结果例如以下：

tom開始办理业务

tom结束办理业务

jim開始办理业务

jim结束办理业务

jay開始办理业务

jay结束办理业务

明显tom、jim、jay仨是排队完毕的。可是无法保证三者的顺序，可能是tom、jim、jay，也可能是tom、jay、jim。由于在入列曾经的运行先后是无法确定的，它的语义是保证一个接一个办理。

假设没有同步器限制的情况。输出结果将不可预測。可能为输出例如以下：

jim開始办理业务

jay開始办理业务

tom開始办理业务

jay结束办理业务

jim结束办理业务

tom结束办理业务





② 共享模式，共享模式採取的样例相同是银行服务窗体，随着此网点的发展。办理业务的人越来越多，一个服务窗体已经无法满足需求，于是又分配了一位员工开了另外一个服务窗体，这时就能够同一时候服务两个人了，但两个窗体都有人占用时相同也必须排队等待，这样的服务窗体同步器装置就是一个共享型。第一个类是共享模式的同步装置类，跟独占模式不同的是它的状态的初始值能够自由定义，获取与释放就是对状态递减和累加操作。第二个类是測试类，tom、jim和jay再次来到银行，一个有两个窗体甚是高兴，他们能够两个人同一时候办理了，时间缩减了不少。

public class BankServiceWindows {

private final Sync sync;

public BankServiceWindows(int count) {

sync = new Sync(count);

}

private static class Sync extends AbstractQueuedSynchronizer {

Sync(int count) {

setState(count);

}

public int tryAcquireShared(int interval) {

for (;;) {

int current = getState();

int newCount = current - 1;

if (newCount < 0 || compareAndSetState(current, newCount)) {

return newCount;

}

}

}

public boolean tryReleaseShared(int interval) {

for (;;) {

int current = getState();

int newCount = current + 1;

if (compareAndSetState(current, newCount)) {

return true;

}

}

}

}





public void handle() {

sync.acquireShared(1);

}





public void unhandle() {

sync.releaseShared(1);

}





}





public class BankServiceWindowsTest {

public static void main(String[] args){

final BankServiceWindows bankServiceWindows=new BankServiceWindows(2);

Thread tom=new Thread(){

public void run(){

bankServiceWindows.handle();

System.out.println("tom開始办理业务");

try {

this.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("tom结束办理业务");

bankServiceWindows.unhandle();

}

};

Thread jim=new Thread(){

public void run(){

bankServiceWindows.handle();

System.out.println("jim開始办理业务");

try {

this.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("jim结束办理业务");

bankServiceWindows.unhandle();

}

};

Thread jay=new Thread(){

public void run(){

bankServiceWindows.handle();

System.out.println("jay開始办理业务");

try {

this.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("jay结束办理业务");

bankServiceWindows.unhandle();

}

};

tom.start();

jim.start();

jay.start();

}

}

可能的输出结果为：

tom開始办理业务

jay開始办理业务

jay结束办理业务

tom结束办理业务

jim開始办理业务

jim结束办理业务

tom和jay差点儿同一时候開始办理业务，而jay结束后有空暇的服务窗体jim才过来。

这节主要讲的是怎样使用AQS构建自己的同步器。而且剖析了锁获取与释放的模板的逻辑，让你更好理解AQS的实现，最后分别给出了独占模式和共享模式的同步器实现的样例。相信你们搞清楚这两种方式的实现后。要构建更加复杂的同步器就知道力往哪里使了。

喜欢研究java的同学能够交个朋友。以下是本人的微信号：