Java AQS

AQS（抽象队列同步器） 代表的是AbstractQueuedSynchronizer类的缩写，该类来自JDK1.5，是JDK提供用于实现依赖于先进先出（FIFO）等待队列的阻塞锁和相关同步器的框架，其类的定义如下：

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable

该类存在几个重要的属性和内部类：

private volatile int state; // 加锁状态
// 下面三个关于state的操作，全部是原子操作
protected final int getState() {
    return state;
}
protected final void setState(int newState) {
    state = newState;
}
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

private transient volatile Node head; // CLH双向队列的头部
private transient volatile Node tail; // CLH双向队列的尾部

private transient Thread exclusiveOwnerThread; // 当前线程

// 同步条件
public class ConditionObject implements Condition, java.io.Serializable {...}
// CLH 双向队列
static final class Node {...}

AQS 重要方法分析（其内部使用了一种设计模式，模板方法模式）：

AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

// 独占锁获取锁
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 简单的自定义锁实现：

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 MyLock implements Lock {
    private Sync sync = new Sync();

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

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

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

    @Override
    public Condition newCondition() {
        return null;
    }
    
    // 自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护，AQS已经在顶层实现好了
    protected class Sync extends AbstractQueuedSynchronizer {
        /**
         * 独占方式，尝试获取资源（共享方式tryAcquireShared）
         * @param arg
         * @return
         */
        @Override
        protected boolean tryAcquire(int arg) {
            assert arg == 1;
            // compareAndSetState 原子操作（CAS）
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        /**
         * 独占方式，尝试释放资源（共享方式tryReleaseShared）
         * @param arg
         * @return
         */
        @Override
        protected boolean tryRelease(int arg) {
            assert arg == 1;
            if (!isHeldExclusively()) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        /**
         * 该线程是否正在独占资源
         * @return
         */
        @Override
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
    }
}

总结：

AQS是JDK提供用于实现依赖于先进先出（FIFO）等待队列的阻塞锁和相关同步器的框架。例如ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock、SynchronousQueue、FutureTask等等都是基于AQS实现的。当然我们也可以利用AQS很方便的实现符合自己要求的同步器。
AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列实现的，即将暂时获取不到锁的线程加入到等待队列中。