从ReentrantLock看AQS的独占式原理解析

文章目录

  • 前言
    • 1.原理概述
    • 2.数据结构
    • 3.源码分析
    • 4.AQS的应用
  • 总结


前言

Java中的大部分同步类都是基于AQS实现的。AQS是一种基于模板方法模式的线程同步框架,提供了独占式EXCLUSIVE和共享SHARED两种模式的同步模板方法。


1.原理概述

AQS的核心思想是如果被请求资源是空闲状态,那么就将当前请求资源的线程设为有效的工作线程,将共享资源设为锁定状态。否则如果共享资源被占用,就需要一套阻塞唤醒线程的机制来保证锁的分配。这个机制主要依靠CLH队列实现,那些获取锁失败的线程会封装成节点加入该队列。

AQS使用一个volatile修饰的int类型的变量state表示同步状态,通过FIFO的双向队列(即CLH队列)完成资源获取排队操作,通过CAS完成对state值的修改。具体如下图所示:从ReentrantLock看AQS的独占式原理解析_第1张图片

2.数据结构

①Node节点

static final class Node {
        /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** Marker to indicate a node is waiting in exclusive mode */
        static final Node EXCLUSIVE = null;

        /** waitStatus value to indicate thread has cancelled */
        static final int CANCELLED =  1;
        /** waitStatus value to indicate successor's thread needs unparking */
        static final int SIGNAL    = -1;
        /** waitStatus value to indicate thread is waiting on condition */
        static final int CONDITION = -2;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         */
        static final int PROPAGATE = -3;
		//当前节点在队列中的状态
        volatile int waitStatus;
		//前驱指针
        volatile Node prev;
		//后继指针
        volatile Node next;
		//当前节点的线程
        volatile Thread thread;
		//指向下一个处于CONDITION状态的节点
        Node nextWaiter;

        /**
         * 共享模式返回true
         */
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        /**
         * Returns previous node, or throws NullPointerException if null.
         * Use when predecessor cannot be null.  The null check could
         * be elided, but is present to help the VM.
         *
         * 返回前驱节点
         */
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() {    // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

在上面原理概述说过,线程会被封装成Node节点,先来看下Node这个数据结构。

属性值和方法 含义
waitStatus 当前节点在队列中的状态
prev 前驱指针
next 后继指针
thread 当前节点的线程
nextWaiter 指向下一个处于CONDITION状态的节点
predecessor 返回前驱节点,没有的话抛出npe

waitStatus有几个枚举值,具体含义在源码中注释写的很明白了,这里简单记录一下

waitStatus 含义
CANCELLED,1 表示取消线程获取锁的请求
SIGNAL,-1 表示线程已经准备好,就等资源释放
CONDITION,-2 表示节点等待在等待队列中,节点线程等待唤醒
PROPAGATE,-3 共享模式下使用,表示需要向下传递
INITIAL,0 Node初始化时的默认值

②同步状态State

private volatile int state;

在AQS源码中,操作state变量的方法都是final修饰的,说明自类无法重写它们。而且对state值的修改都是原子操作,通过CAS实现。

3.源码分析

我们先看一下ReentrantLock中非公平锁的加锁代码实现,即AQS中独占式锁的实现相关

static final class NonfairSync extends Sync {
    ...
    final void lock() {
    	//如果加锁时CAS修改同步状态成功,即获取锁成功,就将当前线程设置为独占线程
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
        	//获取锁失败,进入acquire方法进行后续操作
            acquire(1);
    }
  ...
}

acquire方法点进去是在AQS类中,代码如下

public final void acquire(int arg) {
	//通过tryAcquire方法尝试获取锁,如果获取成功就不再向后执行,否则,就要将当前线程加入等待队列
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

acquire方法流程如图所示:
从ReentrantLock看AQS的独占式原理解析_第2张图片

tryAcquire方法在AQS中只是定义了一个模板方法,具体实现是在子类中实现的

// java.util.concurrent.locks.AbstractQueuedSynchronizer
//AQS中protected修饰的方法都在子类中有对应的实现
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

例如在ReentrantLock的独占锁实现如下

protected final boolean tryAcquire(int acquires) {
			//重写tryAcquire方法,调用自己的nonfairTryAcquire方法
            return nonfairTryAcquire(acquires);
        }
final boolean nonfairTryAcquire(int acquires) {
			//获取当前线程
            final Thread current = Thread.currentThread();
            //获取同步状态(共享资源)
            int c = getState();
            //如果共享资源没有被占用
            if (c == 0) {
            	//CAS占锁
                if (compareAndSetState(0, acquires)) {
                	//占锁成功,将线程设置为独占线程,返回true
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //当前线程是占锁线程
            else if (current == getExclusiveOwnerThread()) {
            	//重复上锁
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //设置新的同步状态值,返回true
                setState(nextc);
                return true;
            }
            return false;
        }

上面说过,如果尝试获取资源失败,会进入acquireQueued(addWaiter(Node.EXCLUSIVE), arg)尝试线程节点获取锁方法,下面先详细说一下addWaiter入队方法,只有先将线程封装成节点入队之后才有可能去竞争释放的资源。

private Node addWaiter(Node mode) {
		//将当前线程和锁模式(独占/共享)封装成一个Node节点
        Node node = new Node(Thread.currentThread(), mode);
        //pred指针指向CLH队列尾节点
        Node pred = tail;
        //如果pred不为null,说明队列中有节点
        if (pred != null) {
        	//将新节点的前驱指针指向pred
            node.prev = pred;
            //通过CAS操作完成尾节点的设置(即将当前节点设为尾节点)
            //这个方法主要是对tailOffset和Expect进行比较,如果tailOffset的Node和Expect的Node地址是相同的,那么设置Tail的值为Update的值
            //private final boolean compareAndSetTail(Node expect, Node update)
            //return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //如果pred是null,说明队列中没有节点或者当前pred指针和tail指向的位置不同(说明被别的线程修改了)那么就要看一下enq方法的实现
        enq(node);
        return node;
    }
    
    //enq方法
    private Node enq(final Node node) {
    	//一个无限循环(即自旋)
        for (;;) {
        	//获取tail节点的指针
            Node t = tail;
            //如果是null,就需要进行初始化,下面的原注释如此
            if (t == null) { // Must initialize
            	//初始化一个头节点,注意这个头节点不是当前线程节点,而是调用Node的一个无参构造方法的节点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
            	//如果是尾节点被其他线程修改,那么获取新的尾节点之后再次使用CAS将当前线程节点入队设为尾节点
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

综上,可以看出,addWaiter()方法就是将当前线程节点入队并设为尾节点的操作,需要注意的是,这个队列的头节点是一个无参构造的头节点。这个入队流程如下图所示:从ReentrantLock看AQS的独占式原理解析_第3张图片
addWaiter()方法执行完成后返回了包含当前线程的节点,而这个节点会作为参数,进入acquireQueued方法,该方法会对队列中的线程进行获取锁的操作。总的来说,一个线程获取锁失败,就被放入等待队列,acquireQueued会把队列中的线程不断去获取锁,直到成功或者中断。下面从“何时出队列”和“如何出队列”两方面分析一下其源码:

final boolean acquireQueued(final Node node, int arg) {
		//标志是否成功获取资源
        boolean failed = true;
        try {
        	//标记等待过程中是否中断
            boolean interrupted = false;
            //自旋,要么获取锁,要么中断
            for (;;) {
            	//获取当前节点的前驱节点,这个方法在Node类中说过
                final Node p = node.predecessor();
                //如果p是头节点,说明当前节点在队列的前端,就可以去尝试获取资源,因为前面说过队列的头节点是个无参构造的节点,实际可以获取资源的是头节点的下一个节点
                if (p == head && tryAcquire(arg)) {
                	//获取资源成功,将当前节点设为头节点,清除thread属性和前驱节点属性
                    setHead(node);
                    //将p节点置为null,方便GC回收
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //`shouldParkAfterFailedAcquire`百度翻译是失败后是否应停止获取,所以下面这段代码意思明了了,即p是头节点且当前节点线程没有获取到锁或者p压根就不是头节点,这个时候就要判断当前节点是否要被阻塞,防止无限循环浪费资源
                //注意这里`shouldParkAfterFailedAcquire`返回true的情况只能是前驱节点处于signal状态,这样才可能阻塞当前线程;否则,当前线程继续自旋尝试获取锁
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
        	//最终获取资源失败
            if (failed)
            	//取消获取资源
                cancelAcquire(node);
        }
    }
    
    //shouldParkAfterFailedAcquire,通过前驱节点判断当前线程是否该被阻塞
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    	//前驱节点的状态值
        int ws = pred.waitStatus;
        //如果前驱节点处于SIGNAL(唤醒)状态,只等资源释放
        if (ws == Node.SIGNAL)
            //那么当前节点可以阻塞,返回true继续`parkAndCheckInterrupt()`执行
            return true;
        //ws>0代表取消状态
        if (ws > 0) {
            //前驱节点已经因为超时或响应了中断取消了当前线程节点,所以需要跨越掉这些CANCELLED节点,直到找到一个<=0的节点
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            //通过CAS设置前驱节点的等待状态为signal
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        //返回false,当前线程继续自旋尝试获取锁
        return false;
    }
    
    //`parkAndCheckInterrupt`主要用于挂起当前线程,阻塞调用栈,返回当前线程的中断状态。
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

出队流程如下图所示:从ReentrantLock看AQS的独占式原理解析_第4张图片
在前面有判断前驱节点状态为等待状态的情况,那么取消节点是怎么生成的?又是在什么时间释放节点通知到被挂起的线程呢?
acquireQueued方法的finally块中,有个cancelAcquire方法,将Node的状态标记为CANCELLED。代码如下:

private void cancelAcquire(Node node) {
        // 将无效的节点过滤
        if (node == null)
            return;
        //将节点的线程设为null,当前节点成为虚节点
        node.thread = null;
        //获取当前节点的前驱节点
        Node pred = node.prev;
        //通过前驱节点,跳过取消状态的节点,将找到的节点作为前驱节点
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;
        //获取过滤后的前驱节点的后继节点
        Node predNext = pred.next;
        //将当前节点设置为取消状态
        node.waitStatus = Node.CANCELLED;
        //如果当前节点是尾节点,将上面获取的当前节点的前驱节点设为尾节点
        if (node == tail && compareAndSetTail(node, pred)) {
        	//更新成功,将尾节点的后继节点设为null
            compareAndSetNext(pred, predNext, null);
        } else {
            //更新尾节点失败
            int ws;
            //如果前驱节点不是头节点
            //1、前驱节点是signal
            //2、前驱节点不是signal和cancel,并且设置为signal成功
            //1或2满足一个条件,并且前驱节点的线程不是null
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                pred.thread != null) {
                //将前驱节点的后继节点设为当前节点的后继节点
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
           		//当前节点是头节点的后继节点或上述条件不成立,唤醒当前节点
                unparkSuccessor(node);
            }
            //将当前节点出队
            node.next = node; // help GC
        }
    }

在上述代码中,一直是在对Next指针做修改,而没有对Perv指针操作,这是为什么?何时会对Prev指针进行操作?
执行cancelAcquire()方法时,可能prev在acquireQueued方法的try代码块中已经出队了,如果此时修改prev指针,可能会导致指向移除队列的节点,不安全。
shouldParkAfterFailedAcquire方法中,执行了node.prev = pred = pred.prev;,这行代码是在获取锁失败的情况下执行的,这时共享资源已被占用,当前节点之前的节点都不会再变化,这时候变更prev更安全。


上面我们对AQS的加锁过程做了介绍,下面对于AQS的解锁流程做一下简单的分析。 先看下ReentrantLock的`unLock`方法,代码如下:
public void unlock() {
        sync.release(1);
    }

可以看出,解锁并不会区分公平锁和非公平锁,最终都是通过继承AQS的sync子类调用AQS的release方法,代码如下:

public final boolean release(int arg) {
		//尝试释放锁,同尝试获取锁类似,这是个模板方法,具体实现看子类实现
		//如果成功,说明资源已被释放
        if (tryRelease(arg)) {
        	//头节点
            Node h = head;
            //头节点不为null且头节点不是初始化状态
            //h==null代表还没有节点入队
            //h.waitStatus == 0代表头节点刚刚初始化
            if (h != null && h.waitStatus != 0)
            	//解除线程挂起状态,该线程可以去获取资源
                unparkSuccessor(h);
            return true;
        }
        //尝试释放锁失败,释放锁失败
        return false;
    }
   
   //ReentrantLock中尝试释放锁的具体实现
   protected final boolean tryRelease(int releases) {
   			//释放后占用次数
            int c = getState() - releases;
            //当前线程不是资源占用线程
            if (Thread.currentThread() != getExclusiveOwnerThread())
            	//抛出异常
                throw new IllegalMonitorStateException();
            //资源释放标志
            boolean free = false;
            if (c == 0) {
            	//如果资源锁定次数为0,即已被释放,标志置为释放
                free = true;
                //将资源占用线程设为null
                setExclusiveOwnerThread(null);
            }
            //修改state值
            setState(c);
            //返回是否资源释放
            return free;
        } 
       
       //看一下唤醒线程的方法 
       private void unparkSuccessor(Node node) {
        //头节点的等待状态
        int ws = node.waitStatus;
        //小于0,将头节点设为初始化状态
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
        //获取头节点的后继节点
        Node s = node.next;
        //如果下个节点是null或下个节点处于取消状态,找队列最开始的非canceled状态节点
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从尾节点向前寻找队列中第一个waitStatus<=0的节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        //如果头节点的下个节点不为null,就把头节点的后继节点唤醒
        if (s != null)
            LockSupport.unpark(s.thread);
    } 

上面就是释放锁的整个流程了,相对于加锁,释放锁就显得简单明了了。总结一下就是,线程释放锁,由于是可重入锁,所以只有将资源的所有重入次数清零,资源才算是真正释放,这时,AQS就会唤醒等待队列的“头节点”(注意这里加了引号,因为不是真正的头节点,而是等待队列中所有有效的等待节点的第一个)去获取资源。

4.AQS的应用

除了ReentrantLock的可重入性应用,AQS作为并发编程框架,还向其他同步工具提供了应用。

同步工具 同步工具与AQS的关联
Semaphore 使用AQS同步状态来保存信号量的当前计数。tryRelease会增加计数,acquireShared会减少计数。
CountDownLatch 使用AQS同步状态来表示计数。计数为0时,所有的Acquire操作(CountDownLatch的await方法)才可以通过。
ReentrantReadWriteLock 使用AQS同步状态中的16位保存写锁持有的次数,剩下的16位用于保存读锁的持有次数。

当然,我们也可以自定义自己的同步工具,去实现一些功能。如下,是一个简单实现:

//自定义的锁
public class AqsDemo {
    private static class Sync extends AbstractQueuedSynchronizer{
        //重写尝试获取锁
        @Override
        protected boolean tryAcquire(int arg){
            return compareAndSetState(0,1);
        }

        //重写尝试释放锁
        @Override
        protected boolean tryRelease(int arg){
            setState(0);
            return true;
        }

        //是否持有资源
        @Override
        protected boolean isHeldExclusively(){
            return getState() == 1;
        }
    }

    private Sync sync = new Sync();

    public void lock(){
        //调用aqs的占资源方法
        sync.acquire(1);
    }

    public void unlock(){
        //调用aqs的释放资源方法
        sync.release(1);
    }
}
测试类,无论运行多少次,count都是2000,当然,这里我用sleep阻塞主线程,让A和B线程执行,其实这不是一个好的方法,仅作为demo测试使用。
public class TestAqsDemo {
    static int count = 0;
    final static AqsDemo aqsDemo = new AqsDemo();

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            aqsDemo.lock();
            System.out.println(Thread.currentThread().getName()+"运行");
            for(int i=0;i<1000;i++){
                count++;
            }
            aqsDemo.unlock();
        },"A").start();
        new Thread(()->{
            aqsDemo.lock();
            System.out.println(Thread.currentThread().getName()+"运行");
            for(int i=0;i<1000;i++){
                count++;
            }
            aqsDemo.unlock();
        },"B").start();
        Thread.sleep(5000);
        System.out.println(count);
    }
}

总结

这篇只针对AQS的独占模型的部分代码进行了分析,而共享式也是很重要的一块内容,需要再去阅读一下代码,丰富一下自己的知识。我觉得文中的几个流程图对于理解代码有很好的帮助,可以考虑自己跟着流程图去阅读源码。最后,再次感谢开源作者的分享。

你可能感兴趣的:(学习总结,java,面试,源码)