详解AQS以及ReentrantLock原理

万能幼年旅店

已于 2023-12-03 15:55:06 修改

阅读量857

点赞数 25

文章标签： java 前端数据库

于 2023-12-03 15:47:22 首次发布

本文链接：https://blog.csdn.net/weixin_53216033/article/details/134765599

版权

AQS原理

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

特点：

使用state属性去表示资源的状态（分为独占和共享），子类需要去定义如何去维护这个状态，控制如何获取锁和释放锁
- getState:获取state状态
- setState:设置state状态
- compareAndSetState:用CAS机制设置state状态
- 独占模式是只允许一个线程去访问共享变量，而共享模式可以运行多个线程去访问共享变量
提供了基于FIFO等待队列(java实现),类似于Monitor的EntryList(c++实现)
条件变量来实现等待，唤醒机制，支持多个条件变量，类似于Monitor的WaitSet

子类主要实现的方法(默认抛出UnspoortOperationException):

tryAcquire：尝试获取锁——只会尝试一次
tryRelease: 尝试释放释放锁

注意：AQS中去阻塞和恢复阻塞使用的是park/unpark机制

下面我们去使用AQS自定义一个不可重入锁

class MyLock implements Lock{
    //独占锁 同步器类
    class MySync extends AbstractQueuedSynchronizer{
        @Override//尝试获取锁
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0,1)){
                //加上了锁，并且设置owner为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override//尝试释放锁
        protected boolean tryRelease(int arg) {
            //因为释放锁不会发生锁竞争，所以不用使用CAS
            setExclusiveOwnerThread(null);
            //注意:State加了voletile关键字，所以把它放在后面修改，添加写屏障，确保前面的不可重排
            setState(0);
            return true;
        }

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

        private Condition newCondition(){
            return new ConditionObject();
        }
    }
    private MySync sync = new MySync();
    @Override //加锁
    public void lock() {
        sync.acquire(1);//会调用tryAcquire方法（不成功则进入等待队列）
    }

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

    @Override   //解锁
    public void unlock() {
        //release会不仅会调用tryRelaese将状态置为0，Owner置为null,
        //还会唤醒阻塞队列中阻塞的线程
        sync.release(1);
    }

    @Override   //新建条件变量
    public Condition newCondition() {
        return sync.newCondition();
    }
}

ReentrantLock

ReentrantLock内部也维护了一个继承于AQS的sync类，但是它是抽象的，子类有公平Sync和非公平Sync

非公平锁的实现原理

加锁解锁流程

从构造器看，ReentrantLock默认为非公平锁

加锁

调用的是sync的lock方法，如下是非公平锁的lock方法源码：

当没有竞争时如下图所示：

当第一个竞争出现的时候：

当CAS尝试将State由0修改为1，结果失败了
然后回进入tryAcquire逻辑，这时state已经是1，结果仍然失败
然后会执行与语句中的addWaiter逻辑，再head中构造Node队列

- 下图中的黄色三角表示该node的waitStatus状态，其中0为默认正常状态
- Node是懒惰创建的
- 第一次创建的时候会创建两个Node节点，第一个是空的，称为哨兵，用来占位，并不关联线程

此时当前线程还是活动的

acquire代码如下:

当前线程进入acquireQueued逻辑

acuireQueued会在一个死循环中不断尝试获得锁，失败后进入park阻塞
如果当前线程的前一个结点是head,那么再次tryAcquire尝试获取锁，当然这时state仍然为1，失败
进入shouldParkAfterFailedAcquire逻辑，将前驱node,即head的waitStatus改为-1(表示当前线程进入阻塞，且该结点有责任将当前线程唤醒),返回false