Java高频面试之--- AQS原理解析

最新推荐文章于 2024-05-24 08:52:55 发布

小猪快跑22

最新推荐文章于 2024-05-24 08:52:55 发布

阅读量6k

点赞数 13

分类专栏： Java-多线程文章标签： AQS 源码解析原理 ReentrantLock

本文链接：https://blog.csdn.net/zhujiangtaotaise/article/details/105843274

版权

Java-多线程专栏收录该内容

24 篇文章 3 订阅

订阅专栏

什么是AQS？AQS有什么用呢？

本篇文章主要就是解决这两个问题，并且附上源码解析。

AQS 的全称是 AbstactQueuedSynchronizer 即抽象队列同步器。

可能大部分使用Java语言的同学都知道它，因为他是面试的高频问题之一，面试Android也会问这样的问题，我自己就被问了好几次。

java并发包下很多API都是基于AQS来实现的加锁和释放锁等功能的，AQS是java并发包的基础类。比如：ReetrantLock ，ReentrantReadWriteLock 都是基于AQS来实现的。

ReentrantLock 实现加锁和锁释放就是通过AQS来实现的。

先看一段代码：

private void doTask1(){
        try {
            reentrantLock.lock();
            Log.e("aqs", "doTask1 获得锁");
            Thread.sleep(3 * 1000);
//            doTask2();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
            Log.e("aqs", "doTask1 释放锁");
        }
    }

如上，如果一个线程调用 lock 会发生什么呢？

其实这个不难，不要一涉及到AQS就觉得很难。AQS 中维护了一个很重要的变量 state, 它是int型的，表示加锁的状态，初始状态值为0；另外 AQS 还维护了一个很重要的变量exclusiveOwnerThread，它表示的是获得锁的线程，也叫独占线程。AQS中还有一个用来存储获取锁失败线程的队列，以及head 和 tail 结点，包含如下图所示
在这里插入图片描述

这时，线程1 跑过来调用ReentrantLock的lock()方法尝试进行加锁，这个加锁的过程，直接就是用CAS操作将state值从0变为1。如果对CAS操作不理解的话，可以看看我之前的文章：我对CAS的理解和用法

如果这时候没有其他的线程操作，那么CAS操作肯定是成功的，然后设置 exclusiveOwnerThread 为当前线程。lock的代码如下（这里是以默认的非公平锁为例）：

final void lock() {
 			//通过CAS操作 ，如果当前的state 等于0 那么 cas 就会操作成功，返回true，表示当前线程成功获取锁
            if (compareAndSetState(0, 1))
                //设置exclusiveOwnerThread 为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

我们从ReentrantLock的名字就可以知道它是可以重入的，那么它的重入是怎么实现的呢？对的，就是跟 state 和 exclusiveOwnerThread 有关，具体是怎么样的呢？看下面的例子

private void doTask1(){
        try {
            reentrantLock.lock();
            Thread.sleep(3 * 1000);
            doTask2();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();     
        }
    }

    private void doTask2(){
        try {
            reentrantLock.lock();         
            Thread.sleep(10 * 1000);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();          
        }
    }

线程先执行 doTask1，然后doTask1中执行doTask2，由于是同一个线程和同一把锁，所以就可以重入了。

具体流程就是：线程执行到doTask2的时候，执行 lock 发现 state 已经不是0而是1了，然后检查当前线程是不是和获取锁的线程是同一个，结果发现是同一个，所以 state+1 = 2，这就是可重入的核心原理。源码如下，在 ReentranLock 中，具体的调用关系我就不列出来了。

 final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //如果 state = 0，那么 通过cas来操作获取锁，跟之前的流程一样，这里为什么还要执行同样的操作呢？因为可能执行到这里的时候，上一个线程刚好执行完，state-- 等于0
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //这里就是可重入的逻辑呢，
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                //小于0表示可重入的次数大于int型最大值，产生溢出了。
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

那么此时，如果线程2 来调用 reentrntlock.lock()方法来获取锁会是什么样子的呢？

线程2跑过来一下看到，发现state的值不是0啊？所以CAS操作将state从0变为1的过程会失败，因为state的值当前为1，说明已经有人加锁了！

接着线程2会看一下，是不是自己之前加的锁啊？当然不是了，exclusiveOwnerThread这个变量明确记录了是线程1占用了这个锁，所以线程2此时就是加锁失败。

加锁失败后是怎么操作的呢？加锁失败后，此时就要将自己放入队列中来等待，等待线程1释放锁之后，自己就可以重新尝试加锁了。

具体的代码如下：

public final void acquire(int arg) {
// tryAcquire 就是调用上面nonfairTryAcquire，由于是线程1没有释放，所以线程2 调用tryAcquire返回false， 接着调用 acquireQueued方法
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

acquireQueued 中先调用 addWaiter ，addWaiter 代码如下：

private Node addWaiter(Node mode) {
        Node node = new Node(mode);

        for (;;) {
            Node oldTail = tail;
            //表示等待队列里有其他的线程在等待了，然后就是设置node为尾结点
            if (oldTail != null) {
              //当前的node的PREV 指向 尾结点oldTail 
                U.putObject(node, Node.PREV, oldTail);
               //把尾结点设置当前的node结点
                if (compareAndSetTail(oldTail, node)) {
                //之前的尾结点的next指向node
                    oldTail.next = node;
                    return node;
                }
            } else {//如果之前的等待队列没有等待的线程，那么new一个node，让head和tail指向这个new出来的结点
                initializeSyncQueue();
            }
        }
    }

上面的把node结点设置为尾结点的操作不知道大家看明白没？我画个图来说明下：
U.putObject(node, Node.PREV, oldTail);
在这里插入图片描述
compareAndSetTail(oldTail, node) 的操作如下，也是通过cas完成的，

oldTail.next = node; 就很简单了，如下：

通过上面的3部操作就可以把获取锁失败的线程放到等待队列的尾部。

接着看看 acquireQueued的源码，如下：

final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
            //判断之前的结点是不是头结点 head，如果是头结点就尝试去获取锁，
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                //获取锁成功的话，就把当前线程设置为head
                    setHead(node);
                    //断开之前头结点
                    p.next = null; // help GC
                    return interrupted;
                }
                //如果之前的不是头结点，那么就要等待了，等候之前的线程释放锁后，调用 LockSupport来唤醒，
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) // 这里很重要，待该线程被唤醒时继续走for循环，设置自己为head结点
                    interrupted = true;
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

接下来先看 shouldParkAfterFailedAcquire，如下：

 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	    // 注意Node的waitStatus字段我们在上面创建Node的时候并没有指定 ，默认值是0    
	    // waitStatus 的4种状态  
	    //static final int CANCELLED =  1;    
	    //static final int SIGNAL    = -1;  //表示有后继结点等待被唤醒  
	    //static final int CONDITION = -2;   //条件锁使用
	    //static final int PROPAGATE = -3; //共享锁时使用
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)           
            return true;
        // 如果 ws > 0，则表示是取消状态，然后通过while循环 把所有是取消状态的线程从等待队列中删除
        if (ws > 0) {           
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {//如果不是取消状态，则通过cas操作将该线程的waitStatus设置为等待唤醒状态           
            pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
        }
        return false;
    }

上面的shouldParkAfterFailedAcquire方法只是将waitStatus设置为SIGNAL，但是并没有阻塞操作，真正的阻塞操作在下面的方法 parkAndCheckInterrupt，如下：

private final boolean parkAndCheckInterrupt() {
        //阻塞当前线程，底层实现是unsafe
        LockSupport.park(this);
        //返回当前线程是否被中断
        return Thread.interrupted();
    }

这里对lock方法作以下总结：

当线程1调用lock方法时，首先看 AQS 的 state 是否为0，如果是0的话，通过cas操作将state置为1，并且设置独占线程为当前线程
如果这时候线程1 要调用另外一个lock方法，就像我上面的例子那样，那么线程1会发现 state = 1，它再去看独占线程是不是就是自己，如果是的话 state + 1 ，获取锁成功。
如果线程1 执行的方法还没有完成即锁还没有释放，此时线程2调用lock方法，由于线程1没有释放锁，那么state不会等于0，且独占线程是线程1而不是自己(线程2)，所以AQS会把线程2放到等待队列的尾部，如果线程2的前置结点是头结点head，那么线程2会通过死循环一直去获取锁，如果还是获取不到锁，那么会阻塞住线程2，下面的图有点问题啊。如果不是头结点那么就会阻塞线程2，等待线程1释放锁且唤醒它。

这里可能有点饶，看下我画的图。
在这里插入图片描述

线程锁释放是怎么样的呢？
我们知道是调用 unlock来实现的，具体是什么样的呢？其实很简单就是将 state-- 直到state = 0，然后通过 LockSupport.unpark()来唤醒等待队列中的下一个结点。具体的看源码：

public void unlock() {
        sync.release(1);
    }

这个没啥子好说的，接着调用AQS的 release方法，如下：

public final boolean release(int arg) {
        //如果释放当前线程成功的话，那么就去唤醒等待队列的头结点
        if (tryRelease(arg)) {
            Node h = head;
            //头结点不为空且waitStatus不等于0
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

来看看 tryRelease 方法，实在Reentrantlock 中实现的，如下：

protected final boolean tryRelease(int releases) {
			//state - 1
            int c = getState() - releases;
            //如果当前线程不是之前设置的独占线程则抛出锁状态异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {//如果c == 0表示当前线程已经释放锁了，然后设置独占线程为null,如果不等于0说明当前线程执行了可重入操作，等可重入的方法执行完 调用 unlock方法，会执行本方法 state会等于0
                free = true;
                setExclusiveOwnerThread(null);
            }
           //state 值置为 0
            setState(c);
            return free;
        }

接下来看看 unparkSuccessor ，如下：

private void unparkSuccessor(Node node) {
        //node 表示是头结点，如果头结点的 waitStatue < 0,则置为0，
        int ws = node.waitStatus;
        if (ws < 0)
            node.compareAndSetWaitStatus(ws, 0);

        //s 表示的是头结点的下一个结点。为什么是唤醒下一个结点而不是头结点呢？
        //因为我们上面调用addWaiter方法的时候，如果等待队列里面没有等待线程，那么直接
        //new 一个Node 然后 head 和 tail 都指向这个 node，换句话说这个头结点只是用来占位的，所以要从头结点的下一个结点开始唤醒
        Node s = node.next;
        //waitStatus 大于0 表示该线程已经取消了，
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从队列的尾部开始遍历，找到一个waitStatue 小于等于0的线程来唤醒
            for (Node p = tail; p != node && p != null; p = p.prev)
                if (p.waitStatus <= 0)
                    s = p;
        }
        if (s != null)//唤醒线程
            LockSupport.unpark(s.thread);
    }

最后再来说一个问题：ReentrantLock 公平和非公平锁的实现

ReentrantLock 默认是非公平锁。
非公平主要体现在假设A线程获取了锁，B 和 C都在等待队列里面等待，然后A释放锁，此时刚好有线程 D 来尝试获取锁且获取成功了；

代码如下：

final void lock() {
// 新线程来获取锁，首先都是尝试将state置为1，成功则表示获取锁，
// 失败则通过 acquire(1) 方法可能将该线程放入等待队列且阻塞该线程
   if (compareAndSetState(0, 1))
       setExclusiveOwnerThread(Thread.currentThread());
   else
       acquire(1);
 }

公平锁：新线程尝试获取锁的时候发现 state 不是0且独占线程不是自己（即有其他的线程已经获取了锁），那么就可能将该线程放入等待队列且阻塞该线程

 final void lock() {
    acquire(1);
 }

结语：AQS 结合 ReentrantLock的加锁和解锁已经介绍完了，有问题可以一起交流交流啊！

小猪快跑22

关注

13
点赞
踩
37

收藏

觉得还不错? 一键收藏
6
评论
Java高频面试之--- AQS原理解析

什么是AQS？AQS有什么用呢？本篇文章主要就是解决这两个问题，并且附上源码解析。AQS 的全称是 AbstactQueuedSynchronizer 即抽象队列同步器。可能大部分使用Java语言的同学都知道它，因为他是面试的高频问题之一，面试Android也会问这样的问题，我自己就被问了好几次。java并发包下很多API都是基于AQS来实现的加锁和释放锁等功能的，AQS是java并发包的...
复制链接

扫一扫