Lock中AbstractQueuedSynchronizer分析

Lock的实现基于队列同步器AbstractQueuedSynchronizer的子类实现的AbstractQueuedSynchronizer用一个int表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。同步器的设计基于模板方法，即开发者需要继承同步器并重写指定的方法，随后同步器组合将在自定义同步组件的过程中，调用同步器的模板方法，这些模板方法又去调用开发者编写的方法。

Lock接口的方法主要为lock(),unlock(),tryLock()(非阻塞式获取锁，没有获取时返回false)等。对于一个需要实现特定需求的Lock(比如独占锁，两个线程共享锁等)，都需要通过实现AbstractQueuedSynchronizer的子类来完成。
AbstractQueuedSynchronizer类中需要重写的方法有：tryAcquire(int ),tryRelease(int),tryAcquireShared(int ),tryReleaseShared(int ),isHeldExclusively().其中前面两个是独占式获取锁和释放锁，后面两个是共享式获取和释放锁，最后一个是当前锁是否被同步器独占。
参考《并发编程的艺术》的例子，

```
public class Mutex implements Lock{

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

    // 当状态为0的是获取锁
    @Override
    protected boolean tryAcquire(int arg) {
    // 如果经过CAS设置状态成功(同步状态设置为1)，则代表获取了同步状态
    if (compareAndSetState(0, 1)) {
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
    }

    // 释放锁，将状态设置为0
    @Override
    protected boolean tryRelease(int arg) {
    if (getState() == 0)
        throw new IllegalMonitorStateException();

    // 将同步状态重置为0.
    setExclusiveOwnerThread(null);
    setState(0);
    return true;
    }

    // 是否处于独占状态
    @Override
    protected boolean isHeldExclusively() {
    return getState() == 1;
    }

    // 返回一个Condition，每个condition都包含了一个condition队列(暂时不管，后面讲这个Condition是干嘛的.)
    Condition newConditio() {
    return new ConditionObject();
    }

    }

    // 静态内部类继承并重写了AbstractQueuedSynchronizer之后，仅需要将操作代理到Sync上即可
    private final Sync sync = new Sync();

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

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

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

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

    // 不是继承来的，原书中这么写的，官方样例也是这么写的,感觉是对外提供的方法
    public boolean isLocked() {
    return sync.isHeldExclusively();
    }

    // 不是继承来的，原书中这么写的，官方样例也是这么写的,感觉是对外提供的方法
    public boolean hasQueueThreads() {
    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));
    }

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub

}

}
这是一个自定义的独占式的锁。其实现Lock接口。内部建立一个内部类Sync，Sync继承同步队列，并重写tryAcquire等方法。
@Override
protected boolean tryAcquire(int arg) {
// 如果经过CAS设置状态成功(同步状态设置为1)，则代表获取了同步状态
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread()); //如果获取锁，就将当前线程设为独占线程
return true;
}
return false;
}

在程序中，使用此独占锁的方法是：mutex.lock();
然后，在mutex的lock方法中，调用了同步队列的sync.acquire(1)方法。

public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}

这个方法的逻辑是：
a.首先调用自定义Sync实现的tryAcquire(arg) 方法，尝试获取独占锁。
b. 如果获取不到，(addWaiter(Node.EXCLUSIVE), arg)就将此线程生成同步队列的node元素节点，并尝试加到队列的结尾。
c. acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法是不断的循环，判断其pre节点是否为头节点，如果是的话，就通过tryAcquire判断是否能独占式获取锁，如果成功的话，将当前节点设为头节点，返回false

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&  //如果没获取到，就将调用LockSupport的park阻塞此线程
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

acquireQueued方法只有获取锁情况下才会返回，返回后，acquire（）方法返回，说明此线程获取锁

在调用Mutex的unlock()方法释放锁时，mutex内部调用Sync的Sync.release(1)方法，同步器中的release方法如下:

public final boolean release(int arg) {
if (tryRelease(arg)) { //调用Sync的tryRelease（）方法对锁的释放
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}

unparkSuccessor(h)通过LockSupport.unpark(s.thread);唤醒后续节点的线程，其中s=h.next;

2、对于共享式获取锁，其区别和独占式获取锁在于：Lock和Unlock方法中，调用的是tryAcquireShared和tryReleaseShared方法。这两个方法是以原子操作设置状态量，比如能被两个线程占用的锁，状态量就在0，1,2之间不断变动，被一个线程占用，状态量就减1，被线程unlock，状态量就加1。

Lock中AbstractQueuedSynchronizer分析

猜你喜欢