一文带你深入理解Java中的AQS!

从ReentrantLock理解AQS的原理及应用总结 本文介绍了Java中的AbstractQueuedSynchronizer(AQS),重点讲解了其在实现ReentrantLock等同步器中的应用。文章分析了AQS的基本概念、工作原理及关键数据结构,并探讨了其在多线程竞争中的线程排队与唤醒机制。通过对AQS实现的深入剖析,帮助开发者更好地理解并发编程中的锁机制和自定义同步器的实现。 阅读详情

01 AQS概述

AbstractQueuedSynchronizer抽象队列同步器简称AQS,它是实现同步器的基础组件,juc下面Lock的实现以及一些并发工具类就是通过AQS来实现的,这里我们通过AQS的类图先看一下大概,下面我们总结一下AQS的实现原理。先看看AQS的类图。

 

 

(1)AQS是一个通过内置的FIFO双向队列来完成线程的排队工作(内部通过结点head和tail记录队首和队尾元素,元素的结点类型为Node类型,后面我们会看到Node的具体构造)。

/*等待队列的队首结点(懒加载,这里体现为竞争失败的情况下,加入同步队列的线程执行到enq方法的时候会创 建一个Head结点)。该结点只能被setHead方法修改。并且结点的waitStatus不能为CANCELLED*/ 
private transient volatile Node head; 
/**等待队列的尾节点,也是懒加载的。(enq方法)。只在加入新的阻塞结点的情况下修改*/ 
private transient volatile Node tail;

(2)其中Node中的thread用来存放进入AQS队列中的线程引用,Node结点内部的SHARED表示标记线程是因为获取共享资源失败被阻塞添加到队列中的;Node中的EXCLUSIVE表示线程因为获取独占资源失败被阻塞添加到队列中的。waitStatus表示当前线程的等待状态:

① CANCELLED=1:表示线程因为中断或者等待超时,需要从等待队列中取消等待;

② SIGNAL=-1:当前线程thread1占有锁,队列中的head(仅仅代表头结点,里面没有存放线程引用)的后继结点node1处于等待状态,如果已占有锁的线程thread1释放锁或被CANCEL之后就会通知这个结点node1去获取锁执行。

③ CONDITION=-2:表示结点在等待队列中(这里指的是等待在某个lock的condition上,关于Condition的原理下面会写到),当持有锁的线程调用了Condition的signal()方法之后,结点会从该condition的等待队列转移到该lock的同步队列上,去竞争lock。(注意:这里的同步队列就是我们说的AQS维护的FIFO队列,等待队列则是每个condition关联的队列)

④ PROPAGTE=-3:表示下一次共享状态获取将会传递给后继结点获取这个共享同步状态。

 

(3)AQS中维持了一个单一的volatile修饰的状态信息state(AQS通过Unsafe的相关方法,以原子性的方式由线程去获取这个state)。AQS提供了getState()、setState()、compareAndSetState()函数修改值(实际上调用的是unsafe的compareAndSwapInt方法)。下面是AQS中的部分成员变量以及更新state的方法

//这就是我们刚刚说到的head结点,懒加载的(只有竞争失败需要构建同步队列的时候,才会创建这个head),如果头节点存在,它的waitStatus不能为CANCELLED 
private transient volatile Node head; 
//当前同步队列尾节点的引用,也是懒加载的,只有调用enq方法的时候会添加一个新的wait node 
private transient volatile Node tail; 
//AQS核心:同步状态 
private volatile int state; 
protected final int getState() {     
          return state; 
} 
protected final void setState(int newState) {     
          state = newState; 
} 
protected final boolean compareAndSetState(int expect, int update) {     
          return unsafe.compareAndSwapInt(this, stateOffset, expect, update); 
}

(4)AQS的设计师基于模板方法模式的。使用时候需要继承同步器并重写指定的方法,并且通常将子类推荐为定义同步组件的静态内部类,子类重写这些方法之后,AQS工作时使用的是提供的模板方法,在这些模板方法中调用子类重写的方法。其中子类可以重写的方法:

//独占式的获取同步状态,实现该方法需要查询当前状态并判断同步状态是否符合预期,然后再进行CAS设置同步状态 
protected boolean tryAcquire(int arg) { 
          throw new UnsupportedOperationException();
} 
//独占式的释放同步状态,等待获取同步状态的线程可以有机会获取同步状态 
protected boolean tryRelease(int arg) { 
          throw new UnsupportedOperationException();
} 
//共享式的获取同步状态 
protected int tryAcquireShared(int arg) { 
          throw new UnsupportedOperationException();
} 
//尝试将状态设置为以共享模式释放同步状态。 该方法总是由执行释放的线程调用。  
protected int tryReleaseShared(int arg) { 
          throw new UnsupportedOperationException(); 
} 
//当前同步器是否在独占模式下被线程占用,一般该方法表示是否被当前线程所独占 
protected int isHeldExclusively(int arg) { 
          throw new UnsupportedOperationException();
}

(5)AQS的内部类ConditionObject是通过结合锁实现线程同步,ConditionObject可以直接访问AQS的变量(state、queue),ConditionObject是个条件变量 ,每个ConditionObject对应一个队列用来存放线程调用condition条件变量的await方法之后被阻塞的线程。

02 AQS中的独占模式

上面我们简单了解了一下AQS的基本组成,这里通过ReentrantLock的非公平锁实现来具体分析AQS的独占模式的加锁和释放锁的过程。

1. 非公平锁的加锁流程

简单说来,AQS会把所有的请求线程构成一个CLH队列,当一个线程执行完毕(lock.unlock())时会激活自己的后继节点,但正在执行的线程并不在队列中,而那些等待执行的线程全部处于阻塞状态(park())。如下图所示。

 

 

(1)假设这个时候在初始情况下,还没有多任务来请求竞争这个state,这时候如果第一个线程thread1调用了lock方法请求获得锁,首先会通过CAS的方式将state更新为1,表示自己thread1获得了锁,并将独占锁的线程持有者设置为thread1。

final void lock() {     
      if (compareAndSetState(0, 1))         
      //setExclusiveOwnerThread是AbstractOwnableSynchronizer的方法,AQS继承了AbstractOwnableSynchronizer         
      setExclusiveOwnerThread(Thread.currentThread());     
      else         
      acquire(1); 
}

(2)这个时候有另一个线程thread2来尝试或者锁,同样也调用lock方法,尝试通过CAS的方式将state更新为1,但是由于之前已经有线程持有了state,所以thread2这一步CAS失败(前面的thread1已经获取state并且没有释放),就会调用acquire(1)方法(该方法是AQS提供的模板方法,它会调用子类的tryAcquire方法)。非公平锁的实现中,AQS的模板方法acquire(1)就会调用NofairSync的tryAcquire方法,而tryAcquire方法又调用的Sync的nonfairTryAcquire方法,所以我们看看nonfairTryAcquire的流程。

//NofairSync 
protected final boolean tryAcquire(int acquires) {     
          return nonfairTryAcquire(acquires); 
} 
final boolean nonfairTryAcquire(int acquires) {     
      //(1)获取当前线程     
      final Thread current = Thread.currentThread();     
      //(2)获得当前同步状态state     
      int c = getState();     
      //(3)如果state==0,表示没有线程获取     
      if (c == 0) {         
          //(3-1)那么就尝试以CAS的方式更新state的值         
          if (compareAndSetState(0, acquires)) {             
                //(3-2)如果更新成功,就设置当前独占模式下同步状态的持有者为当前线程             
                setExclusiveOwnerThread(current);             
                //(3-3)获得成功之后,返回true             
                return true;         
          }     
      }     
      //(4)这里是重入锁的逻辑     
     else if (current == getExclusiveOwnerThread()) {         
          //(4-1)判断当前占有state的线程就是当前来再次获取state的线程之后,就计算重入后的state         
          int nextc = c + acquires;         
         //(4-2)这里是风险处理         
         if (nextc < 0) 
             // overflow             
             throw new Error("Maximum lock count exceeded");         
            //(4-3)通过setState无条件的设置state的值,(因为这里也只有一个线程操作state的值,即         
            //已经获取到的线程,所以没有进行CAS操作)         
            setState(nextc);         
            return true;     
        }      
       //(5)没有获得state,也不是重入,就返回false     
       return false; 
}

总结来说就是:

  • 获取当前将要去获取锁的线程thread2。

  • 获取当前AQS的state的值。如果此时state的值是0,那么我们就通过CAS操作获取锁,然后设置AQS的线程占有者为thread2。很明显,在当前的这个执行情况下,state的值是1不是0,因为我们的thread1还没有释放锁。所以CAS失败,后面第3步的重入逻辑也不会进行

  • 如果当前将要去获取锁的线程等于此时AQS的exclusiveOwnerThread的线程,则此时将state的值加1,这是重入锁的实现方式。

  • 最终thread2执行到这里会返回false。

(3)上面的thread2加锁失败,返回false。那么根据开始我们讲到的AQS概述就应该将thread2构造为一个Node结点加入同步队列中。因为NofairSync的tryAcquire方法是由AQS的模板方法acquire()来调用的,那么我们看看该方法的源码以及执行流程。

//(1)tryAcquire,这里thread2执行返回了false,那么就会执行addWaiter将当前线程构造为一个结点加入同步队列中 
public final void acquire(int arg) {     
       if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))         
          selfInterrupt(); 
}

那么我们就看一下addWaiter方法的执行流程。

private Node addWaiter(Node mode) {     
       //(1)将当前线程以及阻塞原因(是因为SHARED模式获取state失败还是EXCLUSIVE获取失败)构造为Node结点     
       Node node = new Node(Thread.currentThread(), mode);     
       //(2)这一步是快速将当前线程插入队列尾部     
       Node pred = tail;     
       if (pred != null) {         
          //(2-1)将构造后的node结点的前驱结点设置为tail         
          node.prev = pred;         
          //(2-2)以CAS的方式设置当前的node结点为tail结点         
          if (compareAndSetTail(pred, node)) {             
             //(2-3)CAS设置成功,就将原来的tail的next结点设置为当前的node结点。这样这个双向队             
             //列就更新完成了            
             pred.next = node;             
             return node;         
          }     
        }     
        //(3)执行到这里,说明要么当前队列为null,要么存在多个线程竞争失败都去将自己设置为tail结点,     
        //那么就会有线程在上面(2-2)的CAS设置中失败,就会到这里调用enq方法     
        enq(node);     
        return node; 
}

那么总结一下add Waiter方法

  • 将当前将要去获取锁的线程也就是thread2和独占模式封装为一个node对象。

  • 尝试快速的将当前线程构造的node结点添加作为tail结点(这里就是直接获取当前tail,然后将node的前驱结点设置为tail),并且以CAS的方式将node设置为tail结点(CAS成功后将原tail的next设置为node,然后这个队列更新成功)。

  • 如果2设置失败,就进入enq方法。

在刚刚的thread1和thread2的环境下,开始时候线程阻塞队列是空的(因为thread1获取了锁,thread2也是刚刚来请求锁,所以线程阻塞队列里面是空的)。很明显,这个时候队列的尾部tail节点也是null,那么将直接进入到enq方法。所以我们看看enq方法的实现

private Node enq(final Node node) {     
        for (;;) {         
            //(4)还是先获取当前队列的tail结点         
            Node t = tail;         
            //(5)如果tail为null,表示当前同步队列为null,就必须初始化这个同步队列的head和tail(建立一个哨兵结点)         
            if (t == null) {              
            //(5-1)初始情况下,多个线程竞争失败,在检查的时候都发现没有哨兵结点,所以需要CAS的             
            //设置哨兵结点             
            if (compareAndSetHead(new Node()))                 
            tail = head;         
         }          
         //(6)tail不为null         
         else {             
                //(6-1)直接将当前结点的前驱结点设置为tail结点             
                node.prev = t;             
                //(6-2)前驱结点设置完毕之后,还需要以CAS的方式将自己设置为tail结点,如果设置失败,             
                //就会重新进入循环判断一遍             
                if (compareAndSetTail(t, node)) {                 
                    t.next = node;                 
                    return t;             
                }         
          }     
       } 
}

enq方法内部是一个自旋循环,第一次循环默认情况如下图所示

  • 首先代码块(4)处将t指向了tail,判断得到t==null,如图(1)所示;

  • 于是需要新建一个哨兵结点作为整个同步队列的头节点(代码块5-1处执行)

  • 完了之后如图(2)所示。这样第一次循环执行完毕。

 

 

第二次循环整体执行如下图所示。

  • 还是先获取当前tail结点然后将t指向tail结点。如下图的(3)

  • 然后判断得到当前t!=null,所以enq方法中进入代码块(6).

  • 在(6-1)代码块中将node的前驱结点设置为原来队列的tail结点,如下图的(4)所示。

  • 设置完前驱结点之后,代码块(6-2)会以CAS的方式将当前的node结点设置为tail结点,如果设置成功,就会是下图(5)所示。更新完tail结点之后,需要保证双向队列的,所以将原来的指向哨兵结点的t的next结点指向node结点,如下图(6)所示。最后返回。

 

 

总结来说,即使在多线程情况下,enq方法还是能够保证每个线程结点会被安全的添加到同步队列中,因为enq通过CAS方式将结点添加到同步队列之后才会返回,否则就会不断尝试添加(这样实际上就是在并发情况下,把向同步队列添加Node变得串行化了)

(4)在上面AQS的模板方法中,acquire()方法还有一步acquireQueued,这个方法的主要作用就是在同步队列中嗅探到自己的前驱结点,如果前驱结点是头节点的话就会尝试取获取同步状态,否则会先设置自己的waitStatus为-1,然后调用LockSupport的方法park自己。具体的实现如下面代码所示

final boolean acquireQueued(final Node node, int arg) {     
      boolean failed = true;     
      try {         
           boolean interrupted = false;         
           //在这样一个循环中尝试tryAcquire同步状态         
           for (;;) {             
                    //获取前驱结点             
                    final Node p = node.predecessor();             
                    //(1)如果前驱结点是头节点,就尝试取获取同步状态,这里的tryAcquire方法相当于还是调             
                    //用NofairSync的tryAcquire方法,在上面已经说过             
                    if (p == head && tryAcquire(arg)) {                 
                       //如果前驱结点是头节点并且tryAcquire返回true,那么就重新设置头节点为node                 
                       setHead(node);                 
                       p.next = null; //将原来的头节点的next设置为null,交由GC去回收它                 
                       failed = false;                 
                       return interrupted;             
                     }             
                     //(2)如果不是头节点,或者虽然前驱结点是头节点但是尝试获取同步状态失败就会将node结点             
                     //的waitStatus设置为-1(SIGNAL),并且park自己,等待前驱结点的唤醒。至于唤醒的细节             
                     //下面会说到             
                     if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())                 
                     interrupted = true;         
            }     
       } finally {         
                     if (failed)             
                     cancelAcquire(node);     
       } 
}

在上面的代码中我们可以看出,这个方法也是一个自旋循环,继续按照刚刚的thread1和thread2这个情况分析。在enq方法执行完之后,同步队列的情况大概如下所示。

 

 

当前的node结点的前驱结点为head,所以会调用tryAcquire()方法去获得同步状态。但是由于state被thread1占有,所以tryAcquire失败。这里就是执行acquireQueued方法的代码块(2)了。代码块(2)中首先调用了shouldParkAfterFailedAcquire方法,该方法会将同步队列中node结点的前驱结点的waitStatus为CANCELLED的线程移除,并将当前调用该方法的线程所属结点自己和他的前驱结点的waitStatus设置为-1(SIGNAL),然后返回。具体方法实现如下所示。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {     
        //(1)获取前驱结点的waitStatus     int ws = pred.waitStatus;     
        //(2)如果前驱结点的waitStatus为SINGNAL,就直接返回true     
        if (ws == Node.SIGNAL)         
        //前驱结点的状态为SIGNAL,那么该结点就能够安全的调用park方法阻塞自己了。         
        return true;     
        if (ws > 0) {         
                     //(3)这里就是将所有的前驱结点状态为CANCELLED的都移除         
                     do {             
                         node.prev = pred = pred.prev;         
                     } 
                     while (pred.waitStatus > 0);         
                         pred.next = node;     
        } else {         
                    //CAS操作将这个前驱节点设置成SIGHNAL。         
                    compareAndSetWaitStatus(pred, ws, Node.SIGNAL);     
        }     
        return false; 
}

所以shouldParkAfterFailedAcquire方法执行完毕,现在的同步队列情况大概就是这样子,即哨兵结点的waitStatus值变为-1。

 

 

上面的执行完毕返回到acquireQueued方法的时候,在acquireQueued方法中就会进行第二次循环了,但是还是获取state失败,而当再次进入shouldParkAfterFailedAcquire方法的时候,当前结点node的前驱结点head的waitStatus已经为-1(SIGNAL)了,就会返回true,然后acquireQueued方法中就会接着执行parkAndCheckInterrupt将自己park阻塞挂起。

private final boolean parkAndCheckInterrupt() {     
        LockSupport.park(this);     
        return Thread.interrupted(); 
}

(5)我们梳理一下整个方法调用的流程,假设现在又有一个thread3线程竞争这个state,那么这个方法调用的流程是什么样的呢。

①首先肯定是调用ReentrantLock.lock()方法去尝试加锁;

②因为是非公平锁,所以就会转到调用NoFairSync.lock()方法;

③在NoFairSync.lock()方法中,会首先尝试设置state的值,因为已经被占有那么肯定就是失败的。这时候就会调用AQS的模板方法AQS.acquire(1)。

④在AQS的模板方法acquire(1)中,实际首先会调用的是子类的tryAcquire()方法,而在非公平锁的实现中即Sync.nofairTryAcquire()方法。

⑤显然tryAcquire()会返回false,所以acquire()继续执行,即调用AQS.addWaiter(),就会将当前线程构造称为一个Node结点,初始状况下waitStatus为0。

⑥在addWaiter方法中,会首先尝试直接将构建的node结点以CAS的方式(存在多个线程尝试将自己设置为tail)设置为tail结点,如果设置成功就直接返回,失败的话就会进入一个自旋循环的过程。即调用enq()方法。最终保证自己成功被添加到同步队列中。

⑦加入同步队列之后,就需要将自己挂起或者嗅探自己的前驱结点是否为头结点以便尝试获取同步状态。即调用acquireQueued()方法。

⑧在这里thread3的前驱结点不是head结点,所以就直接调用shouldParkAfterFailedAcquire()方法,该方法首先会将刚刚的thread2线程结点中的waitStatue的值改变为-1(初始的时候是没有改变这个waitStatus的,每个新节点的添加就会改变前驱结点的waitStatus值)。

⑨thread2所在结点的waitStatus改变后,shouldParkAfterFailedAcquire方法会返回false。所以之后还会在acquireQueued中进行第二次循环。并再次调用shouldParkAfterFailedAcquire方法,然后返回true。最终调用parkAndCheckInterrupt()将自己挂起。

每个线程去竞争这个同步状态失败的话大概就会经历上面的这些过程。假设现在thread3经历上面这些过程之后也进入同步队列,那么整个同步队列大概就是下面这样了.

 

 

将上面的流程整理一下大概就是下面这个图

 

 

2. 非公平锁的释放流程

上面说一ReentrantLock为例到了怎样去获得非公平锁,那么thread1获取锁,执行完释放锁的流程是怎样的呢。首先肯定是在finally中调用ReentrantLock.unlock()方法,所以我们就从这个方法开始看起。

(1)从下面的unlock方法中我们可以看出,实际上是调用AQS的release()方法,其中传递的参数为1,表示每一次调用unlock方法都是释放所获得的一次state。重入的情况下会多次调用unlock方法,也保证了lock和unlock是成对的。

public void unlock() {     
       sync.release(1); 
       //这里ReentrantLock的unlock方法调用了AQS的release方法 
} 
public final boolean release(int arg) { 
       //这里调用了子类的tryRelease方法,即ReentrantLock的内部类Sync的tryRelease方法     
       if (tryRelease(arg)) {         
              Node h = head;         
              if (h != null && h.waitStatus != 0)             
              unparkSuccessor(h);         
              return true;     
       }     
       return false; 
}

(2)上面看到release方法首先会调用ReentrantLock的内部类Sync的tryRelease方法。而通过下面代码的分析,大概知道tryRelease做了这些事情。

①获取当前AQS的state,并减去1;

②判断当前线程是否等于AQS的exclusiveOwnerThread,如果不是,就抛IllegalMonitorStateException异常,这就保证了加锁和释放锁必须是同一个线程;

③如果(state-1)的结果不为0,说明锁被重入了,需要多次unlock,这也是lock和unlock成对的原因;

④如果(state-1)等于0,我们就将AQS的ExclusiveOwnerThread设置为null;

⑤如果上述操作成功了,也就是tryRelase方法返回了true;返回false表示需要多次unlock。

protected final boolean tryRelease(int releases) {     
          //(1)获取当前的state,然后减1,得到要更新的state     
          int c = getState() - releases;     
          //(2)判断当前调用的线程是不是持有锁的线程,如果不是抛出IllegalMonitorStateException     
          if (Thread.currentThread() != getExclusiveOwnerThread())         
          throw new IllegalMonitorStateException();     
          boolean free = false;     
          //(3)判断更新后的state是不是0     
          if (c == 0) {         
                       free = true;         
                       //(3-1)将当前锁持者设为null         
                       setExclusiveOwnerThread(null);     
          }     
          //(4)设置当前state=c=getState()-releases     
          setState(c);     
          //(5)只有state==0,才会返回true     
          return free; 
}

(3)那么当tryRelease返回true之后,就会执行release方法中if语句块中的内容。从上面我们看到,

if (tryRelease(arg)) {     
   //(1)获取当前队列的头节点head     
   Node h = head;     
   //(2)判断头节点不为null,并且头结点的waitStatus不为0(CACCELLED)     
   if (h != null && h.waitStatus != 0)         
   //(3-1)调用下面的方法唤醒同步队列head结点的后继结点中的线程         
   unparkSuccessor(h);     
   return true; 
}

(4)在获取锁的流程分析中,我们知道当前同步队列如下所示,所以判断得到head!=null并且head的waitStatus=-1。所以会执行unparkSuccessor方法,传递的参数为指向head的一个引用h.那下面我们就看看unparkSuccessor方法中处理了什么事情。

 

 

private void unparkSuccessor(Node node) {     
        //(1)获得node的waitStatus     
        int ws = node.waitStatus;     
        //(2)判断waitStatus是否小于0     
        if (ws < 0)         
        //(2-1)如果waitStatus小于0需要将其以CAS的方式设置为0         
        compareAndSetWaitStatus(node, ws, 0);     
        //(2)获得s的后继结点,这里即head的后继结点     
        Node s = node.next;     
        //(3)判断后继结点是否已经被移除,或者其waitStatus==CANCELLED     
        if (s == null || s.waitStatus > 0) {         
            //(3-1)如果s!=null,但是其waitStatus=CANCELLED需要将其设置为null         
            s = null;         
            //(3-2)会从尾部结点开始寻找,找到离head最近的不为null并且node.waitStatus的结点         
            for (Node t = tail; t != null && t != node; t = t.prev)             
            if (t.waitStatus <= 0)                 
            s = t;     
         }     
         //(4)node.next!=null或者找到的一个离head最近的结点不为null     
         if (s != null)         
         //(4-1)唤醒这个结点中的线程         
         LockSupport.unpark(s.thread); 
 }

从上面的代码实现中可以总结,unparkSuccessor主要做了两件事情:

①获取head节点的waitStatus,如果小于0,就通过CAS操作将head节点的waitStatus修改为0

②寻找head节点的下一个节点,如果这个节点的waitStatus小于0,就唤醒这个节点,否则遍历下去,找到第一个waitStatus<=0的节点,并唤醒。

(5)下面我们应该分析的是释放掉state之后,唤醒同步队列中的结点之后程序又是是怎样执行的。按照上面的同步队列示意图,那么下面会执行这些

①thread1(获取到锁的线程)调用unlock方法之后,最终执行到unparkSuccessor方法会唤醒thread2结点。所以thread2被unpark。

②再回想一下,当时thread2是在调用acquireQueued方法之后的parkAndCheckInterrupt里面被park阻塞挂起了,所以thread2被唤醒之后继续执行acquireQueued方法中的for循环(到这里可以往前回忆看一下acquireQueued方法中的for循环做了哪些事情);

③for循环中做的第一件事情就是查看自己的前驱结点是不是头结点(按照上面的同步队列情况是满足的);

④前驱结点是head结点,就会调用tryAcquire方法尝试获取state,因为thread1已经释放了state,即state=0,所以thread2调用tryAcquire方法时候,以CAS的方式去将state从0更新为1是成功的,所以这个时候thread2就获取到了锁

⑤thread2获取state成功,就会从acquireQueued方法中退出。注意这时候的acquireQueued返回值为false,所以在AQS的模板方法的acquire中会直接从if条件退出,最后执行自己锁住的代码块中的程序。

 

【Java并发编程】4. 一文搞定JUC半壁江山 AQS 文章目录AQSAQS了解AQS中模版模式AQS重要方法模板方法独占式获取共享式获取独占式释放共享式释放子类需实现方法独占式获取独占式释放共享式获取共享式释放 AQS AQS了解 在JDK中我们一般用AQS来构建跟实现显示锁,语言层面我们一般用Syn来实现。AQS(AbstractQueuedSynchronizer 抽象队列同步器),在上一文中被广泛使用。比如CountDownLatch,Thre... 阅读详情

相关推荐

深入理解AQS:Java并发编程中的核心组件

在Java并发编程中,AbstractQueuedSynchronizer(简称AQS)是一个至关重要的基础组件。它为实现锁和其他同步器(例如信号量、事件等)提供了框架支持。本文将详细介绍AQS的概念、内部实现机制及其在实际应用中的使用方法。

fudaihb的博客 1771

AQS详解

整体框架 实现了Lock和Serializable接口 内部Sync类继承自AQS,并重写了tryAcquire和treRelease方法 AQS中的volatile变量state用于记录锁的持有状态和重入次数,1代表有有一个线程持有此锁,n代表当前线程冲入了n次 维护一个双端队列存储竞争锁的线程,队列的头节点是虚节点 AQS中的Node节点,waitStatus 1:该节点的线程可能由于超时或被中断而处于被取消(作废)状态 0:节点被创建的初始值 -1:有后续节点需要被唤醒 加锁流程 ...

weixin_46313750的博客 737

嵌入式充电协议深度解析:从QC到PD3.1的技术演进与实战应用

本文深入解析了从QC到PD3.1的嵌入式充电协议技术演进与实战应用。通过电压谈判、协议芯片设计、Type-C接口优化等关键技术,详细介绍了快充协议在嵌入式系统中的实现挑战与解决方案,包括兼容性测试、EMC问题处理及空间限制创新设计,为开发者提供了宝贵的实践经验。

weixin_29194817的博客 422

AQS层层剖析

在源码中,tryAcquire方法是被protected修饰,参数是int值,代表队state的修改,在共享模式下,可能会有多个线程正在共享资源,所以state需要表示线程占用的数量,所以是int类型的。然后程序将会从队列的尾节点开始搜索,找到除了head之外最靠前的节点,即head的后面一个(第二个)当一个线程以共享模式获取锁时,其他也想以共享模式获取锁的线程,也能够争抢锁,从而一起访问共享资源。在AQS的FIFO队列中,头结点其实是一个虚节点,意思是说,头结点并不是当前需要去拿锁的节点,...

qq_45830289的博客 956

论文精读-ReTransformer ReRAM-based Processing-in-MemoryArchitecture for Transformer Acceleration

Transformer已经成为一种流行的深度神经网络(DNN)模型,用于神经语言处理(NLP)应用,并在神经机器翻译、实体识别等方面表现出优异的性能。然而,其在自回归解码器中的规模化点积注意机制在推理过程中带来了性能瓶颈。Transformer也是计算和内存密集型的,需要硬件加速解决方案。

a284365的博客 1923

CentOS7下用FreeRADIUS+AD实现802.1X认证完整指南(附华为交换机配置)

本文提供了在CentOS 7系统上部署FreeRADIUS并与Windows Active Directory集成,以实现企业级802.1X网络认证的完整实战指南。内容涵盖从架构原理、服务器配置(包括Kerberos、Samba Winbind集成)、FreeRADIUS核心设置与AD联动,到华为交换机的详细配置步骤。重点解决了生产环境中常见的高可用、动态VLAN下发及深度排错问题,为企业构建集中、安全的网络准入控制体系提供了经过验证的解决方案。

weixin_29273849的博客 408

深入分析AQS实现原理

AQS基本的概念 AQS的全称是AbstractQueuedSynchronizer是一个抽象同步队列,它提供了FIFO队列,是一个用来实现同步锁以及其他涉及到同步功能的核心组件,常见的有:ReetrantLock、CountDownLatch等 AQS是一个抽象类,主要是通过继承的方式来使用,它本身没有实现任何的同步接口,仅仅是定义了同步状态的获取以及释放的方法来提供自定义的同步组件 lock与synchronized区别 Lock基于AQS封装的锁,结合CAS实现 Synchronized是基于C++虚

ctycsdn的博客 456

RTX4090上跑CenterNet训练

参考实现 url=https://github.com/xingyizhou/CenterNet.git commit_id=5b1a490a52da57d3580e80b8bb4bbead9ef2af96

遗失的神庙 1624

AQS第二篇 —— AQS的初步认识

AQS内部体系架构 ( state变量+CLH双端Node队列 ) AQS的两个重要构成 AQS的int变量 state AQS的CLH队列 一、AQS的同步状态State成员变量 查看底层源码 /** * 同步状态 */ private volatile int state; state成员变量,用来记录锁的占有情况 当state = 0 ,表示当前锁并没有被线程占有,处于空闲状态 当state = 1 ,表示锁被某个线程占有,其他想要占有锁的线程 就应该进入

weixin_45844836的博客 317

如何让C++程序生成dump文件?生成dump文件的方式有哪些?如何使用Windbg分析dump文件?

本文详细介绍了如何让C++程序生成dump文件、生成dump文件的多种方式以及如何使用Windbg分析dump文件,并给出了对应的实战分析案例,有一定的实战参考价值。

dvlinker的技术专栏 5万+

最新Python爬虫实战(入门爬虫篇)——案例8:图书网畅销榜数据采集(详细爬虫思路截图+抓包动图演示+完整爬虫代码+详细注释)

本次案例通过 Python 爬虫技术,成功实现了对图书网畅销榜多页数据的批量爬取与 Excel 保存。代码采用模块化设计,包含分页参数构造、API 接口请求、JSON 数据解析、Excel 数据持久化等完整流程;通过配置模拟浏览器的请求头,有效规避基础反爬策略,保证请求的稳定性。整个爬虫逻辑遵循 “分页遍历 → 接口请求 → JSON 解析 → 提取图书信息 → 保存到 Excel” 的标准流程,与电商类接口爬取范式高度一致。

努力让自己发光,对的人才能迎着光而来 29万+

AQS 为什么有一个虚拟的 head 节点?

设计选择解决的问题性能影响虚拟头节点统一操作逻辑,避免边界条件处理减少代码分支,提升稳定性从后向前遍历应对并发插入导致的链表断裂保证遍历的可靠性waitStatus 状态机精确控制线程唤醒/取消的传播减少无效唤醒,降低CPU消耗这种设计使得 AQS 在管理高并发线程时,既能保证线程安全,又能将关键操作的时间复杂度控制在O(1)(如状态判断)和O(n) 最坏情况(遍历取消节点)之间,达到性能与稳定性的平衡。

weixin_55358075的博客 1257

SAP 采购订单入库——移动类型

业务场景:采购入库,实物入库至仓库,然后系统同步过账。MIGO:收货、采购订单。 MVT:101 入库,---库存增加。 MVT:移动类型,就是代表业务场景,(比如入库、发货,成本中心发、工单发、报废、盘赢、盘亏等等) 移动类型 1、正向采购入库:101 2、反向冲销(MIGO)102:与101相反,用于错误操作的反向冲销。参考原凭证,全部进行一...

willieyuan的博客 7782

深入理解Java并发核心:AQS

AQS,全称,意为抽象队列同步器。它是一个用于构建锁和同步器的框架,提供了一种实现依赖于先进先出(FIFO)等待队列的阻塞锁和相关同步器的机制。AQS的核心思想是,如果被请求的共享资源空闲,那么就将当前请求资源的线程设置为有效的工作线程,将共享资源设置为锁定状态;如果共享资源被占用,就需要一套线程阻塞等待以及被唤醒时锁分配的机制,AQS就是解决了这个问题。AQS之所以被称为“抽象队列同步器”,是因为它提供了一个灵活的框架,允许开发者通过继承AQS并实现其抽象方法来构建自己的同步器。

weixin_56018532的博客 1700

【24E】SWT6652 wifi驱动加载失败问题分析及解决方案

修改驱动配置Kconfig。是由于内存分配失败导致。

wgl307293845的博客 219

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Java并发之王:AQS揭秘 —— 从源码到应用,一文带你深入理解Java并发核心

获取锁的顺序非公平锁:不保证顺序,线程直接尝试获取锁。公平锁:保证顺序,线程按等待队列中的顺序获取锁。性能非公平锁:通常性能更好,因为它减少了线程在获取锁时的等待时间。公平锁:性能可能较低,因为它增加了线程在获取锁时的等待时间。吞吐量非公平锁:吞吐量通常更高,因为它减少了线程的等待时间。公平锁:吞吐量可能较低,因为它增加了线程的等待时间。线程等待队列非公平锁:线程直接尝试获取锁,可能不会立即加入等待队列。公平锁:线程在尝试获取锁之前,会先检查等待队列,如果队列中有其他线程,则加入队列。

赵KK的博客 1266

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

深入理解 AQS 底层实现原理

AQS的相关介绍: 可重入锁: 是指同一个线程在外层方法获取锁的时候,在内层仍然可以使用,并且不会发生死锁(前提: 锁对象是同一个锁) 不会因为之前已经获取锁还没有释放而阻塞 java中ReentrantLock和syncronized都是可重入锁,可重入锁的一个优点是可一定程度避免死锁 总结: 一个线程中的多个流程可以获取同一把锁,持有这把同步锁可以再次进入 自己可以获取自己的内部锁 可重入锁的种类: 隐式锁:关键字syncronized使用的锁,默认是可重入锁 (同步代码块,同步方法) 显式锁: 即(L

莫言zero的博客 9163

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

一文带你看懂Java中的Lock锁底层AQS到底是如何实现的

相信大家对Java中的Lock锁应该不会陌生,比如ReentrantLock,锁主要是用来解决解决多线程运行访问共享资源时的线程安全问题。那你是不是很好奇,这些Lock锁api是如何实现的呢?本文就是来探讨一下这些Lock锁底层的AQS( AbstractQueuedSynchronizer)到底是如何实现的。本文是基于ReentrantLock来讲解,ReentrantLock加锁只是对AQS的api的调用,底层的锁的状态(state)和其他线程等待(Node双向链表)的过程其实是由AQS来维护的我们先来

yangjnsjbad的博客 337

Java 深入理解 AQS 和 CAS 原理

理解了 AQS 的设计思路,接下来我们就可以通过自定义 AQS 来实现自己的同步实现机制。代码中的 MyLock 就是一个最简单的独占锁,通过使用 MyLock 也能实现同 synchronized 和 ReentrantLock 相同的功能。比如如下代码:最终打印的 count 值为 20000,说明两个线程之间是线程安全的同步操作。

帅次的博客 1433

Java中的锁(深入理解AQS)

一、队列同步器 AbstractQueuedSynchronizer 队列同步器 AbstractQueuedSynchronizer,是用来构建锁或者其他同步组件的基础框架,它使用了一个int成员变量表示同步状态,通过内置的FIFO 队列来完成资源获取线程的排队工作。 1. AQS的使用 AQS的设计是基于模板方法模式的,也就是说,使用者需要继承同步器并重写指定的方法,随后将同步器组合在自定义同步组件的实现中,并调用同步器提供的模板方法,而这些模板方法将会调用使用者重写的方法 ...

weixin_48922154的博客 1696

深入理解Java中的AQS

目录 AQS概述 AQS中的独占模式 非公平锁的加锁流程 非公平锁的释放流程 回到顶部 AQS概述 ​ AbstractQueuedSynchronizer抽象队列同步器简称AQS,它是实现同步器的基础组件,juc下面Lock的实现以及一些并发工具类就是通过AQS来实现的,这里我们通过AQS的类图先看一下大概,下面我们总结一下AQS的实现原理。先看看AQS的类图。 ​(1)AQS是一个通过内置的FIFO双向队列来完成线程的排队工作(内部通过结点head和tail记录队首和队尾元素,..

u011277123的博客 733

深入理解java并发编程之aqs框架

JUC中的同步器三个主要成员:CountDownLatch、CyclicBarrier和Semaphore,通过它们可以方便的实现很多线程之间的协助功能。CountDownLatch叫倒计数,允许一个或者多个线程等待某些操作完成。跑步比赛,裁判需要等到所有运动员都跑到终点才能计算成绩。模拟并发,需要启动100个线程同时访问某个地址,希望他们能并发执行而不是一个一个执行。

初学者 2187

深入理解Java AQS:从原理到源码分析

AQS是用于`实现锁和同步器`的框架。提供了`双向链表的node节点等待队列`,`可实现公平和非公平性`。`提供了state变量`,在不同的同步器中,代表了不同的含义

一名后端程序猿 1860

深入理解AQS

java.util.concurrent包中的⼤多数同步器实现都是围绕着共同的基础⾏为,⽐如等待队列、条件队列、独占获取、共享获取等,⽽这些⾏为的抽象就是基于AbstractQueuedSynchronizer(简称AQS) 实现的,AQS是⼀个抽象同步框架,可以⽤来实现⼀个依赖状态的同步器。我们可以利用AQS非常轻松的构造出我们所需要的同步器。

2301_79754038的博客 1255

Java 并发编程之AQS

AbstractQueuedSynchronizer (AQS) 是 Java 并发编程中的一个核心框架,广泛用于构建锁和其他同步器(如信号量、读写锁等)。它是 java.util.concurrent.locks 包的一部分。AQS 的设计目的是简化并发同步器的实现。理解 AQS 对于深入理解 Java 并发编程非常重要。

微笑听雨 6764
上一篇: java并发异步编程: 原来十个接口的活现在只需要一个接口就搞定!
下一篇: 一次Spring Boot假死诊断。。。
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值