多线程-AbstractQueuedSynchronizer（AQS）

标签：lindeclarednal子类nsafailedpublicbstthis

概述

从使用者的角度，AQS的功能可分为两类：独占功能和共享功能。它的子类中，要么实现并使用了它独占功能的API，要么使用了共享锁的功能，而不会同时使用两套API，即使是它的子类ReentrantReadWriteLock，也是通过两个内部类：读锁和写锁，分别实现的两套API来实现的。

// AQS主要的属性，接口public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable { // 同步状态值
private volatile int state; // 队列头结点，一般获取锁的线程在头结点
private transient volatile Node head; // 队尾节点
private transient volatile Node tail; // 队列缓存对象
static final class Node {} // 获取独占资源，模板方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
} // 子类实现
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
} // 释放独占资源，模板方法
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
} // 释放资源，子类实现
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
} // 获取共享资源，模板方法
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
} // 获取共享资源，子类实现
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
} // 释放共享资源，模板方法
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
} // 释放共享资源，子类实现
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
} // 是否独占？子类实现
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}
}

AQS是一个典型的模板方法模式：AQS定义模板方法，子类实现具体的方法。

模板方法模式：定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

模板方法模式是一种基于继承的代码复用技术，它是一种类行为型模式。

类图

本文从AQS两个典型的应用类ReeantrantLock和CountDownLatch分别介绍独占和共享两个模式。

CAS操作

JDK中很多的线程安全操作依赖于CAS + 循环的无锁模式，AQS中大量使用。

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;

static {
try {
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField(\”state\”));
headOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField(\”head\”));
tailOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField(\”tail\”));
waitStatusOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField(\”waitStatus\”));
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField(\”next\”));

} catch (Exception ex) { throw new Error(ex); }
}

/**
* 设置头结点，期望值为null
*/
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}

/**
* 设置尾节点
*/
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

/**
* 设置一个节点的waitStatus
*/
private static final boolean compareAndSetWaitStatus(Node node,
int expect,
int update) {
return unsafe.compareAndSwapInt(node, waitStatusOffset,
expect, update);
}

/**
* 设置一个节点的next
*/
private static final boolean compareAndSetNext(Node node,
Node expect,
Node update) {
return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
}