5.2 队列同步器

同步器（AbstractQueuedSynchronizer）是实现锁或者说任意同步组件的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。
同步器和锁的关系：锁是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程并行访问），隐藏了实现细节；同步器面向的是锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。

5.2.1 队列同步器的接口与示例

同步器的设计基于模板设计模式。

访问修改同步状态的方法：

1. getState():获取当前同步状态
2. setState(int newState):设置当前同步状态
3. compareAndSetState(int except,int update): 使用CAS设置当前状态，该方法可以保证状态设置的原子性。

同步器可以重写的方法：

1. boolean tryAcquire(int arg) : 独占式获取同步状态
2. boolean tryRelease(int arg) : 独占式释放同步状态
3. int tryAcquireShared(int arg) : 共享式获取同步状态，返回大于等于0的值意味成功
4. boolean tryReleaseShared(int arg) : 共享式释放同步状态
5. bolean isHeldExclusively(): 当前线程是否在独占模式下被线程占用，一般表示是否被当前线程所独占

同步器提供的模板方法：

1. void acquire(int arg) : 独占式获取同步状态，如果当前线程获取同步状态成功，则返回，否则会进入同步队列等待，该方法将会调用重写的tryAcquire(int arg)方法
2. void acquireInterruptibly(int arg) : 与上一个方法一样，但是该方法响应中断，如果当前线程未获取到同步状态则进入同步队列，如果当前线程被中断，则该方法会抛出InterruptedException并返回。
3. boolean tryAcquireNanos(int arg,long nanos) : 在acquireInterruptibly(int arg)的基础上，增加了超时限制，如果当前线程在超时时间内获取到了同步状态，则返回true,反之，则返回false.
4. void acquireShared(int arg): 共享式的获取同步状态，如果当前线程未获取到同步状态，则会进入同步队列中等待，与独占式的不同，可能在同一个时刻可以有多个线程获取到同步状态。
5. void acquireSharedInterruptibly(int arg) : 与acquireShared相同,只是该方法响应中断
6. boolean tryAcquireSharedNanos(int arg,long nanos):在上面方法的基础上，增加了超时控制
7. boolean release(int arg):独占式的释放同步状态，该方法会在释放同步状态之后，将同步队列中的第一个节点包含的线程唤醒。
8. boolean releaseShared(int arg):共享式的释放同步状态
9. Collection< Thread > getQueuedThreads(): 获取等待在同步队列上的线程集合

上述方法大体分为三类：独占式获取与释放同步状态、共享式获取与释放同步状态、查询同步队列中的等待线程情况。

独占锁的示例代码：

public class Mutex implements Lock {
//静态内部类，自定义同步器
private static class Sync extends AbstractQueuedSynchronizer {
    //是否处于占用状态
    @Override
    protected boolean isHeldExclusively() {
        return getState() == 1;
    }

    //当状态为0时获取锁
    @Override
    public boolean tryAcquire(int acquires) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    //释放锁，将状态设置为0
    @Override
    protected boolean tryRelease(int releases) {
        if (getState() == 0) {
            throw new IllegalMonitorStateException();
        }
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    //返回一个Condition,每个Condition都包含了一个condition队列
    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() {
    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();
}

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

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