Java 基于AQS实现自定义同步器的示例

下面我会详细讲解Java 基于AQS实现自定义同步器的示例，包括以下内容：

1. 自定义同步器的基本概念和AQS的应用
2. 自定义同步器的实现步骤和示例说明
3. 示例一：自定义同步器实现独占锁
4. 示例二：自定义同步器实现共享锁

1. 自定义同步器的基本概念和AQS的应用

自定义同步器是指用户自行设计的数据结构，可用于实现不同类型的锁和同步机制。在Java中，实现同步器常使用AbstractQueuedSynchronizer（简称AQS）类作为基类，通过重写内部的同步方法，实现自定义同步器的功能。

AQS是基于FIFO队列的、用于构建锁和同步器的框架，其内部使用state变量维护同步状态，通过Acquire和Release操作对同步状态进行操作，从而实现线程的排队和唤醒。

2. 自定义同步器的实现步骤和示例说明

自定义同步器的实现步骤如下：

1. 定义同步状态变量（一般使用private volatile int state变量）
2. 实现tryAcquire方法和tryRelease方法（不同的同步器实现方式不同）
3. 实现可重入性（可选）
4. 实现Condition接口（可选）

下面通过两个示例说明自定义同步器的实现方法。

3. 示例一：自定义同步器实现独占锁

独占锁可以保证同一时刻只有一个线程可以访问共享资源，其他线程需要等待该线程释放锁后才能继续执行。下面给出一个自定义独占锁的示例：

public class Mutex implements java.io.Serializable {
    private static class Sync extends AbstractQueuedSynchronizer {
        // 是否占用状态
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        // 当状态为0的时候获取锁
        public boolean tryAcquire(int acquires) {
            assert acquires == 1; // 这里限定只能为1个量
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 释放锁，将状态设置为0
        protected boolean tryRelease(int releases) {
            assert releases == 1; // 这里限定只能为1个量
            if (getState() == 0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        // 返回一个Condition，每个condition都包含了一个condition队列
        Condition newCondition() { return new ConditionObject(); }
    }

    // 同步对象完成一些工作，把操作代理到Sync上面执行
    private final Sync sync = new Sync();

    // 加锁操作，代理到acquire方法
    public void lock()             { sync.acquire(1); }
    // 释放锁操作，代理到release方法
    public void unlock()           { sync.release(1); }
    // 返回一个Condition，代理到Sync上面的方法
    public Condition newCondition() { return sync.newCondition(); }
    public boolean isLocked()      { return sync.isHeldExclusively(); }
    public boolean tryLock()       { return sync.tryAcquire(1); }
    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
}

在上述代码中，Sync类继承了AQS类，并重写了tryAcquire和tryRelease方法。通过getState和compareAndSetState方法实现获取锁和释放锁的逻辑。Mutex类作为锁的外观类，提供了lock、unlock、newCondition等方法。使用时可以先通过lock方法获取锁，然后执行完需要执行的代码后再调用unlock方法释放锁。

4. 示例二：自定义同步器实现共享锁

共享锁可以允许多个线程同时访问共享资源，但在同一时刻只能有有限的线程数，超过线程数的其他线程只能等待。下面给出一个自定义共享锁的示例：

public class ShareLock implements java.io.Serializable {
    private static class ShareSync extends AbstractQueuedSynchronizer {
        // 状态state, 状态的前16位表示获取锁的共享线程数量
        // 16位后的状态表示当前持有独占锁的线程
        private int state;
        // 尝试获取共享锁, 若成功, 则返回剩余可重入次数
        protected int tryAcquireShared(int red) {
            for (;;) {
                int current = getState();
                int avail = current >>> 16;
                int remain = current & 0xffff;
                if (avail == 0) { // 没有线程占用共享锁
                    if (compareAndSetState(current, current + (red << 16) + 1)) {
                        setExclusiveOwnerThread(Thread.currentThread());
                        return remain;
                    }
                } else if (exclusiveOwnerThread() == Thread.currentThread()) { // 当前线程已经持有独占锁
                    if (compareAndSetState(current, current + (red << 16))) {
                        return remain;
                    }
                } else { // 其他线程占用共享锁
                    return -1;
                }
            }
        }
        // 尝试释放共享锁, 并返回剩余可重入次数
        protected boolean tryReleaseShared(int arg) {
            for (;;) {
                int current = getState();
                int avail = current >>> 16;
                int remain = current & 0xffff;
                if (avail == 0) return false; // 没有线程占用共享锁
                int next = current - (arg << 16);
                if (next < 0) next = 0;
                if (compareAndSetState(current, next)) {
                    if (next == 0) setExclusiveOwnerThread(null);
                    return remain == 0;
                }
            }
        }
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
    }
    // 同步对象完成一些工作，把操作代理到ShareSync上面执行
    private final ShareSync sync = new ShareSync();
    // 读锁：获取共享锁的操作, 代理到acquireShared方法
    public void lockShared()             { sync.acquireShared(1); }
    // 写锁：释放锁的操作, 代理到releaseShared方法
    public void unlockShared()           { sync.releaseShared(1); }
    public boolean isLocked()      { return sync.isHeldExclusively(); }
}

在上述代码中，ShareSync类继承了AQS类，并重写了tryAcquireShared和tryReleaseShared方法。通过getState、compareAndSetState方法实现共享锁的获取和释放逻辑。ShareLock类作为锁的外观类，提供了lockShared、unlockShared方法。使用时可以先通过lockShared方法获取共享锁，然后执行完需要执行的代码后再调用unlock方法释放锁。