怎么利用AbstractQueuedSynchronizer实现自定义同步组件？

实现步骤

1. 确定访问模式。是共享的还是独占的？是否需要公平？

实现内部静态类(常用类名为Sync)继承AbstractQueuedSynchronizer。根据访问模式确定重写哪种方法：
可重写的方法：

方法名称	描述
protected boolean tryAcquire(int arg)	独占式获取同步状态，实现该方法需要查询当前状态并判断同步状态是否符合预期，然后再进行CAS设置同步状态。
protected boolean tryRelease(int arg)	独占式释放同步状态，等待获取同步状态的线程将有机会获取同步状态。
protected int tryAcquireShared(int arg)	共享式获取同步状态，返回>=0的值，表示获取成功，反之失败
protected boolean tryReleaseShared(int arg)	共享式释放同步状态
protected boolean isHeldExclusively()	当前同步器是否在独占模式下被线程占用，一般该方法表示是否被当前线程独占

2. 定义资源数。是确定的还是参数设置的？

在静态内部类时一般都是用参数表示资源，在组合时会选择继续传参数还是固定值。资源数也就是状态数，个人习惯称为资源数。

3. 组合自定义同步器。是否需要使用模板方法？

这里比较灵活，有的实现有调用有的没有。实现自定义同步组件时，可以调用同步器提供的模板方法：

方法	描述
void acquire(int arg)	独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则，将会进入同步队列等待，该方法会调用重写的tryAcquire(int arg)方法
void acquireInterruptibly(int arg)	与acquire(int arg)相同，但该方法响应中断，当前线程未获取到同步状态而进入同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException并返回
boolean tryAcquireNanos(int arg,long nanos)	在acquireInterruptibly(int arg)上增加了超时方法，超时时间内获取返回true，否则false
void acquireShared(int arg)	共享式获取同步状态，和独占式区别在同一时刻可以有多个线程获取到同步状态
void acquireSharedInterruptibly(int arg)	和上面的方法相同但是响应中断
boolean tryAcquireSharedNanos(int arg,long nanos)	在上面方法基础上增加了超时
boolean release(int arg)	独占式的释放同步状态，该方法在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒
boolean releaseShared(int arg)	共享式的释放同步状态
Collection getQueuedThreads	获取等待在同步队列上的线程集合

用CountDownLatch验证

确定访问模式

CountDownLatch支持多线程访问，但是对资源数做限制。所以首先是共享的。就CountDownLatch功能来说，线程的先后顺序也并不重要，所以不需要公平。

可以看到，这里实现的静态内部类继承了AQS并重写了关于shared（共享的）方法。

确定资源数

CountDownLatch的资源数不确定，由传入自定义同步组件的参数决定。

组合自定义同步器

这里特别灵活。像CountDownlatch只是进行了一层简单的封装。

用Semaphore验证

确定访问模式

Semaphore支持多线程访问，但是对资源数做限制。所以首先是共享的。Semaphore可以是公平的。

可以看到，这里实现的静态内部类继承了AQS并重写了关于shared（共享的）方法。需要注意这里reducePermits和drainPermits不是重写的方法，而是自定义的方法。

这一段代码实现了公平机制，其中：


公平和非公平的区别在于这段代码：

if (hasQueuedPredecessors())
	return -1;

这是AQS里的方法，用来判断当前执行的线程是否位于队列头部。因为队列是后进先出的，所以头结点是最先进去的，也就是公平的定义。

确定资源数

Semaphore的资源数不确定，由传入自定义同步组件的参数决定。

组合自定义同步器

Semaphore在组合时就复杂了非常多，但是还是围绕shared体系的方法，所以一开始就要确定是否是共享的。

自定义同步组件Mutex(独占锁)

ReentrantLock这里不展开讲了，首先它是独占的，然后也可以是公平的，资源数恒定为1。

独占锁也就是在同一时刻只有一个线程获取到锁，而其他请求锁的线程只能在同步队列中排队~这里用实现自定义同步组件Mutex为例：

确定访问模式

独占锁线程独占资源，所以用非shared那套。可以实现公平也可以不实现公平，这里偷个懒实现非公平的。

确定资源数

在锁这里感觉资源称为状态好点ヽ(￣▽￣)و。两个状态0,1。0代表获取1个线程获取到了同步资源，1代表没有线程获取到资源。

组合自定义同步器

这里由于独占锁也是锁，可以作为一种Lock的实现，实现Lock。这一步更多的是思考这个自定义同步器要实现什么功能。对于大部分的功能类库中都有实现。

以下是完整代码：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Mutex implements Lock {

    private final Sync sync = new Sync();

    private static class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            } else return false;
        }

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

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

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

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

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

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

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

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

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

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

该实例中，独占式Mutex是一个自定义同步组件。

参考文献

《Java并发编程的艺术》