AQS 原理

1.* AQS 原理

1.概述

全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的==同步器类==工具的框架 (其它同步器工具类继承它，重用它的功能)

特点：

• 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁
  • getState - 获取 state 状态
  • setState - 设置 state 状态
  • compareAndSetState - cas 机制设置 state 状态
  • 独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源
• 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList条件
  • EntryList是在c++层面实现的，aqs是纯java实现
• 条件变量来实现等待、唤醒机制，支持多个条件变量，
  • 具体的某个条件变量类似于 Monitor 的 WaitSet（持有锁后，但条件不满足，就放弃锁，进入到WaitSet中等待）

子类主要实现这样一些方法（默认抛出 UnsupportedOperationException）

• tryAcquire
• tryRelease
• tryAcquireShared
• tryReleaseShared
• isHeldExclusively

获取锁的姿势

// 如果获取锁失败
if (!tryAcquire(arg)) { // 只会尝试1次
    // 入队, 可以选择阻塞当前线程    (park&unpark机制实现阻塞当前线程或恢复当前线程)
}

释放锁的姿势

// 如果释放锁成功
if (tryRelease(arg)) {
    // 让阻塞线程恢复运行
}

2.自定义锁

有了自定义同步器，很容易复用 AQS ，实现一个功能完备的自定义锁

@Slf4j
public class TestAqs {

    public static void main(String[] args) throws InterruptedException {
        MyLock lock = new MyLock();

        log.debug("main start");

        lock.lock();

        Thread t1 = new Thread(() -> {

            log.debug("t1 start");
            lock.lock();           // t1此时将拿不到锁,所以将会进入队列等待main线程释放锁,
            log.debug("t1 end");   //    main线程释放锁后,t1线程拿到锁后,继续运行

        }, "t1");
        t1.start();

        Thread.sleep(2000);
        log.debug("main开始释放锁...");
        lock.unlock();
        log.debug("main释放锁成功");

    }

}

// 自定义锁 (不可重入锁)
class MyLock implements Lock{

    private MySync sync = new MySync();

    // 独占锁  同步器类
    class MySync extends AbstractQueuedSynchronizer{

        @Override
        protected boolean tryAcquire(int arg) {
            // 将state通过cas改为1的线程,将会加锁成功
            if (compareAndSetState(0, 1)) {
                // 加上了锁,并设置 owner为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            setExclusiveOwnerThread(null);
            // state变量被volatile修饰,保存在同步器父类AQS中,
            //    将对state状态变量的写操作放在设置owner线程下方,是为了防止指令重排序
            setState(0);
            return true;
        }

        @Override // 是否持有独占锁
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        public Condition newCondition() {
            return new ConditionObject(); // AQS类中的public类ConditionObject,它实现了Condition接口
        }

    }

    @Override // 加锁 ( 不成功, 进入等待队列 )
    public void lock() {
        sync.acquire(1);
    }

    @Override // 加锁 (不成功，进入等待队列, 可打断)
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override // 尝试加锁 (尝试1次, 不成功返回，不进入队列)
    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();
    }

}

不可重入测试
如果改为下面代码，会发现自己也会被挡住（只会打印一次 locking）

lock.lock();
log.debug("locking...");
lock.lock(); // 第二次又去获取锁,但是该锁是不可重入锁
log.debug("locking...");