使用Java的AQS组件自定义一把锁

使用Java的AQS组件自定义一把锁

AQS

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

AQS有如下特点：

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

同步器AQS的子类主要对以下方法进行实现

• tryAcquire()：尝试获取锁

• tryRelease()：尝试释放锁

• tryAcquireShared()

• tryReleaseShared()

• isHeldExclusively():判断是否线程独占

获取锁的姿势

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

释放锁的姿势

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

使用AQS自定义一把不可重入锁

第一步：实现一个同步器（实现AQS）

只需要实现几个基本功能，则AQS的其他默认实现会调用你实现的基本功能

/*自定义同步器，只需要继承AQS，并实现基本功能即可*/
final class MySync extends AbstractQueuedSynchronizer {

    /*实现获取锁*/
    @Override
    protected boolean tryAcquire(int acquires) {
        if (acquires==1){
            //0代表无线程持有锁，1代表有线程持有锁，此处通过CAS将锁状态边为1
            if (compareAndSetState(0,1)){
                setExclusiveOwnerThread(Thread.currentThread());
                return true ;
            }
        }
        return false ;
    }

    /*实现释放锁*/
    @Override
    protected boolean tryRelease(int acquires) {
        if (acquires == 1){
            //如果锁状态为0，即无线程持有,抛出对象头状态异常
            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();
    }
}

第二步：编写一个锁类，需要继承JUC的Lock接口，该接口定义了一个锁的基本方法，利用我们上面的AQS，可以很轻松的实现Lock接口

class MyLock implements Lock{
    //一个myLock对象共享一个同步器，故用static
    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() {
        //返回AQS的条件变量
        return sync.newCondition();
    }
    
}

测试：

    /*test*/
    public static void main(String[] args) {
        MyLock lock = new MyLock() ;
        new Thread(()->{
            lock.lock();
            try {
                System.out.println("t1 locking ..."+new Date());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }finally {
                System.out.println("t1 unlocking ..."+new Date());
                lock.unlock();
            }
        }).start();

        new Thread(()->{
            lock.lock();
            try {
                System.out.println("t2 locking ..."+new Date());
            }finally {
                System.out.println("t2 unlocking ..."+new Date());
                lock.unlock();
            }
        }).start();
    }

结果：

t1 locking …Sat Jun 20 19:30:15 CST 2020
t1 unlocking …Sat Jun 20 19:30:16 CST 2020
t2 locking …Sat Jun 20 19:30:16 CST 2020
t2 unlocking …Sat Jun 20 19:30:16 CST 2020

t1先上锁，等待一秒解锁，t2得以执行，证明这个自定义锁写的没问题

AQS想法小结

AQS 要实现的功能目标：

• 阻塞版本获取锁 acquire 和非阻塞的版本尝试获取锁 tryAcquire

• 获取锁超时机制

• 通过打断取消机制

• 独占机制及共享机制

• 条件不满足时的等待机制

AQS设计小结：

AQS 的基本思想其实很简单

• 获取锁的逻辑

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

• 释放锁的逻辑

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

要点：

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

state设计：

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

阻塞恢复设计：

• 早期的控制线程暂停和恢复的 api 有 suspend 和 resume，但它们是不可用的，因为如果先调用的 resume 那么 suspend 将感知不到

• 解决方法是使用 park & unpark 来实现线程的暂停和恢复，具体原理在之前讲过了，先 unpark 再 park 也没问题

• park & unpark 是针对线程的，而不是针对同步器的，因此控制粒度更为精细

• park 线程还可以通过 interrupt 打断

在

Sychronized原理的最后，我特别提到了park&unpark的原理，不清楚的可翻阅

阻塞队列设计：

• 使用了 FIFO 先入先出队列，并不支持优先级队列

• 设计时借鉴了 CLH 队列，它是一种单向无锁队列

  • CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。

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

    入队伪代码，只需要考虑 tail 赋值的原子性

    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 的并发工具类