提升--09---AQS源码解析--(抽象的队列式同步器)

已于 2023-11-21 19:33:56 修改
阅读量298 收藏
点赞数
分类专栏： 多线程高并发 文章标签： java
于 2021-09-20 19:09:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48052161/article/details/120388129
版权

文章目录

ReentrantLock—源码解析

在这里插入图片描述

AQS的本质是JUC包下一个抽象类，AbstractQueuedSynchronizer （抽象的队列式同步器）

以下jdk版本----JDK11

在这里插入图片描述

案例debug

import java.util.concurrent.locks.ReentrantLock;

public class TestReentrantLock {
    private static volatile int i = 0;

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();

        try {
            i++;
        } finally {
            lock.unlock();
        }

    }

}

UML图

在这里插入图片描述

debug开始

在这里插入图片描述

ReentrantLock

  • ReentrantLock调用它lock()方法的时候，它会调用acquire(1)方法，谁的acquire？是Sync的acquire，这很容易理解，
    在这里插入图片描述

NonfairSync

  • 在我们的lock方法里它调用了内部的一个类，这个类叫NonfairSync，NonfairSync它里边有个方法叫acquire(1)

在这里插入图片描述

AbstractQueuedSynchronizer----(AQS)

抽象的队列式同步器

在这里插入图片描述

  • NonfairSync的父类是Sync，因为你看到NonfairSync子类里方法的时候，它有可能用到父类的方法，所以你要去父类里读才可以，
  • NonfairSync的父类是Sync，好这个时候再回到Sync，这个时候我们看一下，这个Sync的父类又是谁？是AQS(AbstarctQueuedSynchronizer)，这个时候说一下AQS是所有锁的核心，
  • 我们继续lock调用了acquire(1)这个方法，是谁的acquire(1)？是NonfairSync的acquire(1)，NonfairSync又是谁？他是Sync的子类，Sync又是谁，Sync是AQS的子类，所以调用了acquire(1)我们再跟进去，这个时候就调用了AQS的acquire(1)了
NonfairSync ==> Sync ==> AQS(AbstractQueuedSynchronizer)

在这里插入图片描述
在这里插入图片描述

tryAcquire(1)

在这里插入图片描述

在这里插入图片描述

  • AQS里面调用的是什么呢？是tryAcquire(1)，再跟进去你会发现这次调用的是NonfairSync里的tryAcquire(1)，刚才我们读的时候已经知道AQS里有一个tryAcquire(1)，但是它里面是抛出了一个异常，所以很容易理解，是NonfairSync里边重写了AQS里的tryAcquire(1)，
  • 所以AQS里的acquire(1)调用了NonfairSync里的tryAcquire(1)，我们再来看NonfairSync里的tryAcquire(1)又调用了nonfairTryAcquire(acquires)，

我们再跟进这个时候读到这里，我们就必须要了解AQS了，如果不懂，就没办法继续进行下去了，

nonfairTryAcquire

在这里插入图片描述

  • 我们看nonfairTryAcquire(acquires)方法实现，开始它得到了当前线程，跟线程有关系了

  • 这个时候出现了一个方法getState()，我们来看一下这个方法，我们跟进你会发现，这个方法又尽到了AQS类里，这个getState()方法返回了一个state，这个state是什么呢？按着ctrl点过去，你会发现这个state就是一个volatile修饰的int类型的数，这个时候就牵扯到AQS的结构了

AQS----源码解析

AQS队列又可以称为CLH队列

在这里插入图片描述

1.state

AQS的核心是什么？就是这个state
注意这个state 是用 volatile修饰

在这里插入图片描述

ReentrantLock的state 0和1就代表了加锁和解锁
  • AQS队列又可以称为CLH队列，AQS的核心是什么？就是这个state，这个state所代表的意思随你定，随子类来定，
  • 我们现在讲的是ReentrantLock，刚才state的值是0，当你获得了之后它会变成1，就表示当前线程得到了这把锁，什么时候你释放完了，state又会从1变回0，说明当前线程释放了这把锁，所以这个state0和1就代表了加锁和解锁，所以这个state的值是根据你子类不同的实现取不同的意义
    在这里插入图片描述

2.AQS队列

AQS的核心是一个state，以及监控这个state的双向列表

在这里插入图片描述
在这里插入图片描述

  • 这个state的值的基础之上，它的下面跟着一个队列，这个队列是AQS自己内部所维护的队列，这个队列里边每一个所维护的都是node一个节点，它在哪里呢？他在AQS这个类里属于AQS的内部类，
Node

在这里插入图片描述

  • 在这个node里最重要的一项是他里面保留了一个Thread一个线程，所以这个队列是个线程队列，
  • 而且还有两个prev和next分别是前面的节点和后面的节点
  • 所以AQS里边的队列是这样子的，一个一个的node，node里装的是线程Thread，这个node它可以指向前面的这一个，也可以指向后面的这一个，所以叫双向列表，

所以AQS的核心是一个state，以及监控这个state的双向列表，每个列表里面有个节点，这个节点里边装的是线程，那么那个线程得到了state这把锁，其他没抢到锁的线程要等待，都要进入这个队列里边，当我们其中一个node得到了state这把锁，就说明这个node里得线程持有这把锁，

3.获取锁的过程

所以当我们acquire(1)上来以后看到这个state的值是0，那我就直接拿到state这个把锁，现在是非公平上来就抢，抢不着就进队列里acquireQueued()，怎么是抢到呢？

  1. 先得到当前线程，然后获取state的值，
  2. 如果state的值等于0，用compareAndSetState(0,acquire)方法尝试把state的值改为1，假如改成了setExclusiveOwnerThread()把当前线程设置为独占statie这个把锁的状态，说明我已经得到这个把锁，而且这个把锁是互斥的，我得到以后，别人是得不到的，因为别人再来的时候这个state的值已经变成1了，
  3. 如果说当前线程已经是独占state这把锁了，就往后加个1就表示可重入了。

4. 什么叫非公平的去获得(nonfairTryAcquire)?

  • 什么叫公平什么叫非公平，当我们获得一把锁的时候，有一些等待队列，如果说新来了一个线程要获得这个锁的时候，先去检查等待队列有没有人，如果有后面排队，这个叫公平，上来二话不说，我才不管你的队列有没有人在等着，我上来就抢，抢着就算我的，插队非公平。
    在这里插入图片描述

通过ReentrantLock来解读AQS源码

回顾:

AQS大家还记得吗？最核心的是它的一个共享的int类型值叫做state，这个state用来干什么，其实主要是看他的子类是怎么实现的，比如ReentrantLock这个state是用来干什么的？拿这个state来记录这个线程到底重入了多少次，比如说有一个线程拿到state这个把锁了，state的值就从0变成了1，这个线程又重入了一次，state就变成2了，又重入一次就变成3等等，什么时候释放了呢？从3变成2变成1变成0就释放了，

这个就是AQS核心的东西，一个数，这个数代表了什么要看子类怎么去实现它，那么在这个state核心上还会有一堆的线程节点，当然这个节点是node，每个node里面包含一个线程，我们称为线程节点，这么多的线程节点去争用这个state，谁拿到了state，就表示谁得到了这把锁，

AQS得核心就是一个共享的数据，一堆互相抢夺竞争的线程，这个就是AQS。

AQS的核心是一个state，以及监控这个state的双向列表

在这里插入图片描述

debug运行程序在这里插入图片描述

1.接着上面来讲，首先给lock()方法处打断点，然后debug运行程序

import java.util.concurrent.locks.ReentrantLock;

public class TestReentrantLock {
    private static volatile int i = 0;

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();

        try {
            i++;
        } finally {
            lock.unlock();
        }

    }

}

2.在lock()方法里里面，我们可以读到它调用了sync.acquire(1)，

//JDK源码
public class ReentrantLock implements Lock, java.io.Serializable {
	public void lock(){
        sync.acquire(1);
    }
}

在这里插入图片描述
3.再跟进到acquire(1)里，可以看到acquire(1)里又调用了我们自己定义自己写的那个tryAcquire(arg)

//JDK源码
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    
	public final void acquire(int arg){
		if(!tryAcquire(arg) 
           && acquireQueued(addWaiter(Node.EXCLUSIVE),arg))
       	 selfInterrupt();
	}
}

在这里插入图片描述
4.跟进到tryAcquire(arg)里又调用了nonfairTrytAcquire(acquires)

//JDK源码
public class ReentrantLock implements Lock, java.io.Serializable {
    
	public void lock(){
        sync.acquire(1);
    }
    
    static final NonfairSync extends Sync{
        protected final boolean tryAcquire(int acquire){
            return nonfairTrytAcquire(acquires);
	   }
    }
}

在这里插入图片描述
5.nonfairTrytAcquire(acquires)方法

//JDK源码
public class ReentrantLock implements Lock, java.io.Serializable {
    
	public void lock(){
        sync.acquire(1);
    }
    
    static final NonfairSync extends Sync{
        protected final boolean tryAcquire(int acquire){
            return nonfairTrytAcquire(acquires);
	   }
    }
    
    final boolean nonfairTrytAcquire(int acquire){
         //获取当前线程
		final Thread current = Thread.currentThread();
        //拿到AQS核心数值state
         int c getState();
        //如果数值为0说明没人上锁
         if(c == 0){
             //给当线程上锁
			if(compareAndSetState(0,acquires)){
                //设置当前线程为独一无二拥有这把锁的线程
			    setExclusiveOwnerThread(current);
                 return true
            }
         }
        //判断当前线程是否拥有这个把锁
        else if(current == getExclusiveOwnerThread){
            //设置重入
			int nextc = c + acquires;
             if(nextc < 0)
                 throw new Error("Maximum lock count wxceeded");
             setState(nextc);
             return true;
         }
        return false;
    }
}

在这里插入图片描述
nonfairTrytAcquire(acquires)我们读进去会发现它的里面就调用到了state这个值，到这里我们就接上了上一章讲的，nonfairTrytAcquire(acquires)里是这样的，

  1. 首先拿到当前线程，拿到state的值，然后进行if判断，
  2. 如果state的值为0，说明没人上锁，没人上锁怎么办呢？就给自己上锁，当前线程就拿到这把锁，拿到这个把锁的操作用到了CAS(compareAndSetState)的操作，从0让他变成1，state的值设置为1以后，设置当前线程是独一无二的拥有这把锁的线程，
  3. 否则如果当前线程已经占有这把锁了，怎么办？很简单我们在原来的基础上加1就可以了，这样就能拿到这把锁了，就重入，前者是加锁后者是重入

6.如果拿不到呢？如果拿不到它实际上是调用了acquireQueued()方法

//JDK源码
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
	public final void acquire(int arg){
        //判断是否得到锁
		if(!tryAcquire(arg) 
           && acquireQueued(addWaiter(Node.EXCLUSIVE),arg))
       	 selfInterrupt();
	}
}
  • 如果拿不到呢？如果拿不到它实际上是调用了acquireQueued()方法，acquireQueued()方法里又调用了addWaiter(Node.EXCLUSIVE)然后后面写一个arg(数值1)，方法结构是这样的acquireQueued(addWaiter(Node.EXCLUSIVE),arg)通过acquireQueued这个方法名字你猜一下这是干什么的，你想如果是我得到这把锁了，想一下后面的acquireQueued是不用运行的，如果没有得到这把锁，后面的acquireQueued()才需要运行，那么想一下没有得到这把锁的时候它会运行什么呢？他会运行acquireQueued，Queued队列，acquire获得，跑到队列里去获得，那意思是什么？排队去，那排队的时候需要传递两个参数，第一个参数是某个方法的返回值addWaiter(Node.EXCLUSIVE)，来看这个方法的名字addWaiter，Waiter等待者，addWaiter添加一个等待者，用什么样的方式呢？Node.EXCLUSIVE排他形式，意思就是把当线程作为排他形式扔到队列里边。
如果拿不到锁,就把当钱线程作为排他形式扔到队列里边

addWaiter()方法----加入双向等待队列

  • 我们来说一下这个addWaiter()方法，这个方法意思是说你添加等待者的时候，使用的是什么类型，如果这个线程是Node.EXCLUSIVE那么就是排他锁，Node.SHARED就是共享锁，首先是获得当前要加进等待者队列的线程的节点，然后是一个死循环，这意思就是说我不干成这件事我誓不罢休，那它干了一件什么事呢？

在这里插入图片描述

//JDK源码
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
	public final void acquire(int arg){
        //判断是否得到锁
		if(!tryAcquire(arg) 
           && acquireQueued(addWaiter(Node.EXCLUSIVE),arg))
       	 selfInterrupt();
	}
    
    private Node addWaiter(Node mode){
        //获取当前要加进来的线程的node(节点)
		Node node = new Node(mode);
        for(;;){
            //回想一下AQS数据结构图
		   Node oldTail = tail;
            if(oldTail != null){
                //把我们这个新节点的前置节点设置在等待队列的末端
				node.setPrevRelaved(oldTail);
                //CAS操作，把我们这个新节点设置为tail末端
                 if(compareAndAetTail(oldTail,node)){
					oldTail.next = node;
                      return node;
                 }
            }else{
                initializeSuncQueue();
            }
        }
    }
}

你想想想看，我们回想一下AQS数据结构图，就是他有一个int类型的数叫state，然后在state下面排了一个队列，这个队列是个双向的链表有一个head和一个tail，

  1. 现在你要往这个队列中加一个节点上来，要排队嘛，我们仔细想一下加节点的话，应该得加到这个队列的末端是不是？它是怎么做到的呢？首先把tail记录在oldTail里，oldTail指向这个tail了，如果oldTail不等于空，它会把我们这个新节点的前置节点设置在这个队列的末端，
  2. 接下来再次用到CAS操作，把我们这个新的节点设置为tail，整段代码看似繁琐，其实很简单，就是要把当前要加进等待者队列的线程的节点加到等待队列的末端，这里提一点，加到末端为什么要用CAS操作呢？因为CAS效率高，这个问题关系到AQS的核心操作，理解了这一点，你就理解了AQS为什么效率高，我们接着讲源码，这个增加线程节点操作，如果没有成功，那么就会不断的试，一直试到我们的这个node节点被加到线程队列末端为止，意思就是说，其它的节点也加到线程队列末端了，我无非就是等着你其它的线程都加到末端了，我加最后一个，不管怎么样我都要加到线程末端去为止。

acquireQueued()----队列里尝试去获得锁

在这里插入图片描述

在这里插入图片描述
解读acquireQueued()这个方法，这个方法的意思是，在队列里尝试去获得锁，在队列里排队获得锁，那么它是怎么做到的呢？我们先大致走一遍这个方法，

  1. 首先在for循环里获得了Node节点的前置节点，
  2. 然后判断如果前置节点是头节点，并且调用tryAcquire(arg)方法尝试一下去得到这把锁，获得了头节点以后，你设置的节点就是第二个，你这个节点要去和前置节点争这把锁，这个时候前置节点释放了，如果你设置的节点拿到了这把锁，拿到以后你设置的节点也就是当前节点就被设置为前置节点，如果没有拿到这把锁，当前节点就会阻塞等着，等着什么？等着前置节点叫醒你，所以它上来之后是竞争，怎么竞争呢？如果你是最后节点，你就下别说了，你就老老实实等着，如果你的前面已经是头节点了，说明什么？说明快轮到我了，那我就跑一下，试试看能不能拿到这把锁，说不定前置节点这会儿已经释放这把锁了，如果拿不着阻塞，阻塞以后干什么？等着前置节点释放这把锁以后，叫醒队列里的线程，我想执行过程已经很明了了，在这里插入图片描述

打个比方，有一个人，他后面又有几个人在后面排队，这时候第一个人是获得了这把锁，永远都是第一个人获得锁，那么后边来的人干什么呢？站在队伍后面排队，然后他会探头看他前面这个人是不是往前走了一步，如果走了，他也走一步，当后来的这个人排到了队伍的第二个位置的时候，发现前面就是第一个人了，等这第一个人走了就轮到他了，他会看第一个人是不是完事了，完事了他就变成头节点了，就是这么个意思。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

锁释放后，只会通知队列中的第一个线程去竞争锁，减少了并发冲突。（ZK的分布式锁，为了避免惊群效应，也使用了类似的方式：获取不到锁的线程只监听前一个节点）

小结;

  • 源码读这里我们可以总结得出，AQS(AbstractQueuedSynchronizer)的核心就是用CAS(compareAndSet)去操作head和tail，就是说用CAS操作代替了锁整条双向链表的操作

几个重要知识点

1.AQS为什么效率这么高?

通过AQS是如何设置链表尾巴的来理解AQS为什么效率这么高

我们的思路是什么呢？假如你要往一个链表上添加尾巴，尤其是好多线程都要往链表上添加尾巴，我们仔细想想看用普通的方法怎么做？

  1. 第一点要加锁这一点是肯定的，因为多线程，你要保证线程安全，一般的情况下，我们会锁定整个链表(Sync)，我们的新线程来了以后，要加到尾巴上，这样很正常，但是我们锁定整个链表的话，锁的太多太大了，现在呢它用的并不是锁定整个链表的方法，而是只观测tail这一个节点就可以了，怎么做到的呢？
  2. compareAndAetTail(oldTail,node)，中oldTail是它的预期值，假如说我们想把当前线程设置为整个链表尾巴的过程中，另外一个线程来了，它插入了一个节点，那么仔细想一下Node oldTail =tail;的整个oldTail还等于整个新的Tail吗？不等于了吧，那么既然不等于了，说明中间有线程被其它线程打断了，那如果说却是还是等于原来的oldTail，这个时候就说明没有线程被打断，那我们就接着设置尾巴，只要设置成功了OK，compareAndAetTail(oldTail,node)方法中的参数node就做为新的Tail了，
所以用了CAS操作就不需要把原来的整个链表上锁，这也是AQS在效率上比较高的核心。

2.为什么是双向链表？

其实你要添加一个线程节点的时候，需要看一下前面这个节点的状态，如果前面的节点是持有线程的过程中，这个时候你就得在后面等着，如果说前面这个节点已经取消掉了，那你就应该越过这个节点，不去考虑它的状态，所以你需要看前面节点状态的时候，就必须是双向的。
,g_se,x_16)

3. VarHandle

jdk9以后才有的
  • 我们再来讲一个细节，我们看addWaiter()这个方法里边有一个node.setPrevRelaved(oldTail)，这个方法的意思是把当前节点的前置节点写成tail，进入这个方法你会看到PREV.set(this,p)，那这个PREV是什么东西呢？

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

当你真正去读这个代码，读的特别细的时候你会发现，PREV有这么一个东西叫VarHandle，这个VarHandle是什么呢？这个东西实在JDK1.9之后才有的，我们说一下这个VarHandle，Var叫变量(variable)，Handle叫句柄，打个比方，比如我们写了一句话叫Object o= new Object()，我们new了一个Object，这个时候内存里有一个小的引用“O”，指向一段大的内存这个内存里是new的那个Object对象，那么这个VarHandle指什么呢？指的是这个“引用” 我们思考一下，如果VarHandle代表“引用”，那么VarHandle所代表的这个值PREV是不是也这个“引用”呢？当然是了。这个时候我们会生出一个疑问，本来已经有一个“O”指向这个Object对象了，为什么还要用另外一个引用也指向这个对象，这是为什么？

通过这个handle可以做什么事呢？

通过这个handle可以做什么事呢？handle.compareAndSet(t,9,10)，做原子性的修改值，我通过handle.compareAndSet(t,9,10)把9改成10改成100，这是原子性的操作，你通过x=100 ，它会是原子性的吗？当然int类型是原子性的，但是long类型呢？就是说long类型连x=100都不是原子性的，所以通过这个handle可以做一些compareAndSet操作(原子操作)，还可以handle.getAndAdd()操作这也是原子操作，

比如说你原来写x=x+10，这肯定不是原子操作，因为当你写这句话的时候，你是需要加锁的，要做到线程安全的话是需要加锁的，但是如果通过handle是不需要的，所以这就是为什么会有VarHandle，VarHandle除了可以完成普通属性的原子操作，还可以完成原子性的线程安全的操作，这也是VarHandle的含义。

VarHandle除了可以完成普通属性的原子操作，还可以完成原子性的线程安全的操作，这也是VarHandle的含义。
  • 在JDK1.9之前要操作类里边的成员变量的属性，只能通过反射完成，
  • 用反射和用VarHandle的区别在于，VarHandle的效率要高的多，反射每次用之前要检查，VarHandle不需要，VarHandle可以理解为直接操纵二进制码，所以VarHandle反射高的多

在这里插入图片描述

知行合一。。。
关注
专栏目录
AQS-3抽象队列同步器
09-15
AQS_3抽象队列同步器
Java抽象队列同步器源码分析（AQS）
Mr_changxin的博客
03-06 637
文章目录AQS1. AQS 概述2. AQS 的数据结构3. 资源共享模式4. AQS 的主要源码解析4.1 获取资源4.2 释放资源 深入理解 synchronized 关键字（关于对象头和锁的升级） 深入理解 volatile 关键字（内存屏障和指令重排问题） AQS 1. AQS 概述 AQS是 AbstractQueuedSynchronizer 的简称，即 抽象队列同步器 ，从字⾯意思上理解: 抽象：抽象类，只实现⼀些主要逻辑，有些⽅法由⼦类实现； 队列：使⽤先进先出（FIFO）队列存储数据；
并发编程面试题——AQS源码解读
weixin_45150104的博客
07-11 582
讲解java并发编程AQS源码
（十一）JDK源码分析之AQS同步队列和等待队列交互图
weixin_38312719的博客
03-18 402
建议 希望读者打开源码对照看，或者有AQS源码基础存在一些疑惑的同学看，一定能有所收获
jdk11 AQS(AbstractQueuedSynchronizer)源码
weixin_41333865的博客
06-22 175
提供了一个框架来实现阻塞锁和依赖先进先出(FIFO)等待队列的相关同步器(信号量、事件等)。 这个类被设计为大多数依赖单个原子int值来表示状态的同步器的有用基础。 子类必须定义改变这种状态的受保护方法，这些方法定义了在获取或释放对象时这种状态的含义。...
AQS原理及源码浅析
qq_44503377的博客
05-14 384
什么是AQS？ AQS 即 AbstractQueuedSynchronizer 抽象队列同步器，它是Java并发用来构建锁和其他同步工具的基础框架，是一个抽象类。AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock、Semaphore、CountDownLatch。 ReentrantLock是如何加锁的？AQS是如何被使用的？ ReentrantLock 通过调用对象的lock()和unlock()方法来加锁解锁，下面分析一下源码中加锁的过程，在
带你看看Java-AQS同步器 源码解读四 条件队列Condition上
12-21
Java AQS（AbstractQueuedSynchronizer）是一个强大的同步组件，它被广泛应用于并发编程中，如Java的Lock接口的实现。AQS的核心是通过一个FIFO（先进先出）的双向队列来管理线程的等待状态。这个队列分为两种类型：...
AQS抽象队列同步器,AQS抽象队列同步器
09-15
AQS抽象队列同步器,AQS抽象队列同步器
JUC(一)-AQS源码分析
01-21
AQS源码分析一、锁的介绍1.1 乐观锁/悲观锁1.2 共享锁/独占锁1.3 公平锁/非公平锁1.4 小结二、AQS框架结构介绍2.1 类图2.2 AQS数据结构三、源码详解3.1 acquire源码详解3.2 release源码详解四、从ReentranLock看公平...
【JDK源码】AQS源码详细解读
flw7758的博客
04-29 382
AQS源码详细解读 什么是AQAS AQS：AbstractQueuedSynchronizer ，它是一个抽象的同步队列器，这个类位于java.util.concurrent.locks包下面，是用来构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个int类型变量麦示持有锁的状态。 主要是通过CLH队列实现对线程的调度。 CLH: Craig、Landin and Hagersten队列，是一个单向链表，AQS中的队列是CL
AQS（抽象队列同步器）详解
maxleader的博客
02-17 551
同步锁的本质 —— 排队 同步的方式：独享锁 - 单个队列窗口，共享锁 - 多个队列窗口； 抢锁的方式：插队抢（非公平锁）、先来后到抢（公平锁）； 没捡到锁的处理方式：快速尝试多次（CAS自旋锁）、阻塞等待； 唤醒阻塞线程的方式（叫号器）：全部通知、通知下一个； AQS概念 资源占用流程 手写抽象队列同步器 import java.util.Iterator; import java.util...
队列同步器(AbstractQueuedSynchronizer)源码简析
Stay Hungry, Stay Foolish!
06-09 883
文章目录1 AQS概述2 AQS常用方法2 AQS实现分析2.1 同步队列2.1.1 入队2.1.2 出列2.2 同步状态2.2.1 独占式(EXCLUSIVE)2.2.2 共享式(SHARED)2.2.3 超时获取方式2.3 阻塞和唤醒线程2.3.1 parkAndCheckInterrupt2.3.2 unparkSuccessor2.3.3 LockSupport3 总结参考资料 文章后续于https://github.com/zgkaii/CS-Study-Notes更新，欢迎批评指正！ 1 A
java juc 分析_JUC源码分析—AQS (基于java11)
weixin_42109639的博客
02-19 282
1. 概述AbstractQueuedSynchronizer，简称AQS。是一个用于构建锁和同步器的框架，许多同步器都可以通过AQS很容易并且高效地构造出来，如常用的ReentrantLock、Semaphore、CountDownLatch等。基于AQS来构建同步器能带来许多好处。它不仅能极大地减少实现工作，而且也不必处理在多个位置上发生的竞争问题。在基于AQS构建的同步器中，只可能在一个时刻...
AQS详解
JAVA那些事
01-09 807
文章目录一、 AQS的类图结构1. state2. Node二、AQS同步队列(CLH)1. AQS同步原理2. AQS同步器的结构—入列与出列2.1 AQS同步器的结构2.2 入列2.3 出列三、 AQS锁1. AQS支持的锁的类别2. 基于AQS实现锁（独占与共享模式）2.1 独占锁的获取2.1.1 acquire()2.1.2 tryAcquire()2.1.3 addWaiter()2....
AQS-基于JDK17
weixin_49561445的博客
10-04 1220
全称是 AbstractQueuedSynchronizer，AbstractQueuedSynchronizer抽象类（以下简称AQS）是整个java.util.concurrent包的核心。是阻塞式锁和相关的同步器工.在JDK1.5时，Doug Lea引入了J.U.C包，该包中的大多数同步器都是基于AQS来构建的。AQS框架提供了一套通用的机制来管理同步状态（synchronization state）、阻塞/唤醒线程、管理等待队列。 我们所熟知的ReentrantLock、CountDownLatch
工厂模式的介绍及实现
户伟伟的博客
09-25 96
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 179
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 827
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
智能BI平台项目
2302_79400545的博客
09-22 223
BI商业智能：数据可视化、报表可视化系统。
Java-AQS同步器：条件队列详解与实战应用
在深入理解Java并发编程时，AQS（AbstractQueuedSynchronizer）同步器是一个关键的概念，它提供了一种高级的线程互斥和同步机制。在AQS的源码分析系列中，第四篇专门探讨了条件队列（Condition）这一特性。条件队列...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值