JUC-AQS(AbstractQueuedSynchronizer)原理

1、概述

全称是AbstractQueuedSynchronizer，是阻塞式锁和相关同步器工具的框架

特点：

• 用state属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁
  • getState - 获取state状态
  • setState - 设置state状态
  • compareAndSetState - cas机制设置state状态
• 提供基于FIFO的等待队列，类似Monitor的EntryList
• 条件变量来实现等待、唤醒机制，支持多个条件变量，类似Monitor的WaitSet

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

• tryAcquire
• tryRelease
• tryAcquireShared
• tryReleaseShared
• isHeldExclusively

获取锁的姿势

// 如果获取锁失败
if (!tryAcquire(arg)) {
	// 入队，可以选择阻塞当前线程 park unpark
}

释放锁的姿势

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

2、实现不可重入锁

自定义同步器

public class MySync extends AbstractQueuedSynchronizer {

    @Override
    protected boolean tryAcquire(int arg) {
        if (arg == 1) {
            if (compareAndSetState(0 ,1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
        }
        return false;
    }

    @Override
    protected boolean tryRelease(int arg) {
        if (arg == 1) {
            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        return false;
    }

    @Override
    protected boolean isHeldExclusively() {
        return getState() == 1;
    }

    protected Condition newCondition() {
        return new ConditionObject();
    }

}

自定义锁

public class MyLock implements Lock {

    private static MySync sync = new MySync();

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

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    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();
    }
}

测试

public static void main(String[] args) {
        MyLock lock = new MyLock();
        new Thread(() -> {
            lock.lock();
            try {
                log.debug("lock...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                log.debug("unlock...");
                lock.unlock();
            }
        }, "t1").start();

        new Thread(() -> {
            lock.lock();
            try {
                log.debug("lock...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                log.debug("unlock...");
                lock.unlock();
            }
        }, "t2").start();

    }

输出

2022/03/27-23:26:56.375 [t1] c.Test1 - lock...
2022/03/27-23:26:57.387 [t1] c.Test1 - unlock...
2022/03/27-23:26:57.387 [t2] c.Test1 - lock...
2022/03/27-23:26:58.398 [t2] c.Test1 - unlock...

不可重入测试

如果修改为下面代码，会发现自己也会被挡住（只会打印一次locking）

lock.lock();
log.debug("lock...");
lock.lock();
log.debug("lock...");

3、心得

起源

早起程序员会自己通过一种同步器去实现另一种相近的同步器，例如用可重入锁去实现信号量，或反之。这显然不够优雅，于是在JSR166（java规范提案）中创建了AQS，提供了这种通用的同步器机制。

目标

AQS要实现的功能目标

• 阻塞版本获取锁acquire和非阻塞版本的尝试获取锁tryAcquire
• 获取锁超时机制
• 通过打断取消机制
• 独占机制及共享机制
• 条件不满足时的等待机制

要实现的性能目标

Instead, the primary performance goal here is scalability: to predictably maintain efficiency even, or
especially, when synchronizers are contended.

设计

AQS的基本思想其实很简单

获取锁的逻辑

while(state 状态不允许获取){
	if(队列中还没有次线程) {
		入队并阻塞
	}
}
当前线程出队

释放锁的逻辑

if(state 状态允许了) {
	回复阻塞的线程s
}

要点

• 原子维护state状态
• 阻塞及恢复线程
• 维护队列

1）state设计

• state使用volatile配合cas保证其修改时的原子性
• state使用了32bit int 来维护同步状态，因为当时使用long在很多平台下的测试结果并不理想

2）阻塞恢复设计

• 早起的控制线程暂停和恢复的api有suspend和resume，但它们是不可用的，因为如果先调用的resume那么suspend将感知不到
• 解决方法是使用park & unpark来实现线程的暂停和恢复，具体原理在之前讲过了，先unpark再park也没有问题
• park & unpark是针对线程的，而不是针对同步器的，因此控制粒度更为精细
• park线程还可以通过interrupt打断

3）队列设计

• 使用了FIFO先入先出队列，并不支持优先级队列
• 设计时借鉴了CLH队列，它是一种单向无锁队列

队列中有head和tail两个指针结点，都用volatile修饰配合cas使用，每个结点有state维护结点状态

入队伪代码

do {
	// 原来的tail
	Node prev = tail;
	// 用cas在原来的tail基础上改为node
} while(tail.compareAndSet(prev, node))

出队伪代码

// prev是上一个节点
while((Node prev = node.prev).state != 唤醒状态) {}
// 设置头结点
head = node;

CLH好处：

• 无锁，使用自旋
• 快速，无阻塞

AQS在一些方面改进了CLH

	private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            // 队列中还没有元素 tail 为 null
            if (t == null) {
                // 将 head 从 null -> dummy
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                // 将 node 的 prev 设置为原来的 tail
                node.prev = t;
                // 将 tail 从原来的 tail 设置为 node
                if (compareAndSetTail(t, node)) {
                    // 原来 tail 的 next 设置为 node
                    t.next = node;
                    return t;
                }
            }
        }
    }

主要用到AQS的并发工具类