同步器（AQS）的设计是基于模板方法模式的，使用者(指的是自定义同步器)需要继承同步器（AQS）并重写AQS指定的方法，随后将同步器(自定义的同步器)组合在自定义同步组件的实现中，并调用同步器（AQS）提供的模板方法，而这些模板方法将会调用使用者(自定义同步器)重写的方法。自定义同步器重写同步器（AQS）指定的方法时（需要同步状态的配合），会用到同步器（AQS）提供的如下3个方法来访问或修改同步状态。
·getState()：获取当前同步状态。
·setState(int newState)：设置当前同步状态。
·compareAndSetState(int expect,int update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性。
根据上面这段文字，对如何构造一个自定义的同步组件总结如下：
1》定义一个继承AQS同步器的静态的私有的内部类；
2》该内部类要重写AQS中指定的方法tryAcquire()和tryRelease()方法；
3》该自定义同步组件调用AQS中提供的模板方法，而这些模板方法将会调用使用者(自定义同步器)重写的方法。
下面是一个例子：独占锁Mutex是一个自定义同步组件，它在同一时刻只允许一个线程占有锁。Mutex中定义了一个静态内部类，该内部类继承了同步器（AQS）并实现了独占式获取和释放同步状态。在tryAcquire(int acquires)方法中，如果经过CAS设置成功（同步状态设置为1），则代表获取了同步状态，而在tryRelease(int releases)方法中只是将同步状态重置为0。用户使用Mutex时并不会直接和内部同步器的实现打交道，而是调用Mutex提供的方法，在Mutex的实现中，以获取锁的lock()方法为例，只需要在方法实现中调用同步器的模板方法acquire(int args)即可，当前线程调用该方法获取同步状态失败后会被加入到同步队列中等待，这样就大大降低了实现一个可靠自定义同步组件的门槛。
import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.AbstractQueuedSynchronizer; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; /** * 自定义一个同步组件（例如这里的Mutex），首先定义一个静态内部私有类，且该类要继承AbstractQueuedSynchronizer这个抽象类 * 重写同步器指定的方法：此时需要同步状态的配合，会用到同步器提供的如下3个方法来访问或修改同步状态。 getState()：获取当前同步状态。 * setState(int newState)：设置当前同步状态。 compareAndSetState(int expect,int * update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性。 */ public class Mutex implements Lock { // 静态内部类，自定义一个同步器。注意：Mutex是同步器组件 private static class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = -4387327721959839431L; // 是否处于占用状态，getState()来自父类 protected boolean isHeldExclusively() { return getState() == 1; } /* 当状态为0（acquires=0）的时候获取锁 重写父类中的方法 * @see java.util.concurrent.locks.AbstractQueuedSynchronizer#tryAcquire(int) * 独占式获取同步状态，实现该方法需要查询当前状态并判断同步状态是否符合预期，然 后在进行CAS设置同步状态 */ public boolean tryAcquire(int acquires) { assert acquires == 1; // Otherwise unused // 获取锁成功后将状态置为1，这样其他线程就不能获取了 if (compareAndSetState(0, 1)) { // 设置当前线程为该锁的拥有者 setExclusiveOwnerThread(Thread.currentThread()); return true; } return false; } // 释放锁，将状态设置为0 protected boolean tryRelease(int releases) { assert releases == 1; // Otherwise unused if (getState() == 0) throw new IllegalMonitorStateException(); // 将该锁设置为不为任何线程所拥有 setExclusiveOwnerThread(null); // 设置状态为0 setState(0); return true; } // 返回一个Condition，每个condition都包含了一个condition队列 Condition newCondition() { return new ConditionObject(); } } // 仅需要将操作代理到Sync(使用Sync完成同步加锁功能)上即可 private final Sync sync = new Sync(); // 获取锁,调用父类中的方法acquire()方法 public void lock() { sync.acquire(1); } // 尝试获取锁 public boolean tryLock() { return sync.tryAcquire(1); } // 释放锁 public void unlock() { sync.release(1); } 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)); } }
