JUC源码分析(一)-AbstractQueuedSynchronizer(AQS)源码分析

最新推荐文章于 2025-02-18 22:50:12 发布
最新推荐文章于 2025-02-18 22:50:12 发布
阅读量617 收藏 3
点赞数
分类专栏： JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jpf254/article/details/79450470
版权
本文详细解析了AQS(AbstractQueuedSynchronizer)的源码，介绍了AQS作为记录型信号量的Java语言实现，其核心方法acquire()和release()对应PV操作，并通过实例分析了线程间的同步互斥过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

背景介绍

AQS

AQS(AbstractQueuedSynchronizer)是JUC下提供的一个同步框架.其名字为抽象队列同步器.
同步器:AQS是一个同步器,可完成同步互斥功能
队列:使用双端双向链表完成同步互斥功能
抽象:AQS是一个抽象类,具体的实现需要子类实现相关方法做支持,JUC中的ReentrantLock,CountDownLatch,Semaphore都是基于AQS来实现
那AQS又是如何使用队列完成同步器功能的呢?在我们已有的知识中有什么机制可以完成同步器功能呢?

答案是:信号量,更准确点说是记录型信号量,AQS就是记录型信号量的Java语言实现

记录型信号量

了解了AQS的基本原理之后,我们就一起回忆下记录型信号量的逻辑,记录型信号量由PV操作组成

P操作

  • 将资源数减一
  • 若资源数减一后小于0,将当前线程加入队列,挂起当前线程

V操作

  • 将资源数加一
  • 若资源数加一后小于等于0,说明队列中有线程存在,则将当前线程移出队列,唤醒当前线程

至于AQS如何实现PV操作?AQS实现的PV操作与传统记录型信号量有何异同?在下文继续分析

AbstractOwnableSynchronizer

AQS继承了AbstractOwnableSynchronizer,AbstractOwnableSynchronizer非常简单,只有一个exclusiveOwnerThread属性和相应的get和set方法
exclusiveOwnerThread:独占模式下持有同步器资源的线程

AbstractQueuedSynchronizer

AQS属性

由背景介绍可知,AQS是记录型信号量的Java语言实现,所以AQS中有一属性state与记录型信号量的资源数含义基本一致,但state的具体含义由子类确定;记录型信号量中使用一个队列记录挂起的线程, 所以AQS中有head和tail分别指向双端链表的头尾结点.

因此AQS中共有state,head,tail三个属性.

AbstractQueuedSynchronizer.Node

由上文知:AQS维护一个双端双向队列,那队列中的每个结点表示什么含义呢?

  • 每个结点表示一个等待获取锁资源的线程

Node就是AQS队列中的结点

  • 所以Node的第一个属性就是thread,代表被Node封装的线程
  • 此外Node中还有一个waitStatus代表Node所处的状态,共取5个值
    • static final int CANCELLED = 1;//
    • static final int SIGNAL = -1;//结点状态:该结点下一个结点需要unparking(唤醒)
    • static final int CONDITION = -2;//结点状态:在某condition上等待
    • static final int PROPAGATE = -3;
    • 0//表示Node为初始状态
  • 由于Node是双端链表的结点,有prev和next分别表示前一个结点和后一个结点.
  • Node还有一个属性nextWaiter,与next的区别在于nextWaiter`表示下一个等待在Condition上的结点(分析Condition时再分析)

重要方法

AQS中有多个公共方法,有是否可中断之分,有是否可设置超时之分的,主要方法为acquire()和release(),acquire()相当于P操作,release()相当于V操作,逻辑如下:

acquire()

  • 尝试获取资源,获取成功,则将资源数减一
  • 若获取失败,则将当前线程加入队列中,挂起当前线程,当V操作唤醒一个线程时,将该线程从队列中移除

releases()

  • 尝试释放资源,释放成功,则唤醒一个队列中被阻塞的线程

可以看出acquire()和release()和PV操作逻辑还是有一些不同之处:

  1. AQS有一个尝试获取资源/尝试释放资源的逻辑,而非直接将资源数加一/减一,该方法在AQS中就是tryAcquire()/tryRelease(),由子类实现,子类可以根据不同的实现丰富AQS的语义
  2. PV操作中V操作除了唤醒队列中被阻塞的线程外,还负责将该线程移出队列,但AQS中将线程加入和移出队列都交由acquire(),由acquire()调用acquireQueued()(极其重要,后面重点分析)完成

我们首先看一下acquire()的实现

AQS将尝试获取资源抽象为tryAcquire(),由子类实现;将当前线程加入等待队列中抽象为addWaiter(),将挂起当前线程,当V唤醒一个线程时,将该线程从队列中移除抽象为acquireQueued();将逻辑1和逻辑2综合抽象为if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

    /**
     * 该方法在独占模式下使用,忽略中断
     * 若第一次tryAcquire()成功:则执行一次tryAcquire()后返回
     * 若第一次tryAcquire()失败:将当前线程入队,而后重复调用tryAcquire()直到成功,期间当前线程将重复挂起和唤醒
     *
     * @param arg the acquire argument. arg将传递给 tryAcquire(),但是arg的含义由子类实现确定,与state的含义一致
     */
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

tryAcquire()由子类实现,分析到具体子类时再详细介绍该函数,现在看下addWaiter()和acquireQueued()的实现

    /**
     * 根据参数mode创建结点,并将其入队
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    private Node addWaiter(Node mode) {
        //根据mode生成新节点,在new Node(mode)时将node.thread设置为当前线程
        Node node = new Node(mode);
        //死循环+CAS
        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                //将当前结点尾插法插入AQS队列中
                node.setPrevRelaxed(oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return node;
                }
            } else {
                //初始化AQS队列,建立头结点.head.thread为null,head.waitStatus=0
                initializeSyncQueue();
            }
        }
    }

到了最重点的acquireQueued()了,由于AQS是一个同步器,而同步器最起码牵涉到两个线程,我们规定下文分析的场景如下:

  1. 只有A,B两个线程争抢一个锁资源
  2. A线程第一次调用tryAcquire()成功,获取锁;B线程第一次调用tryAcquire()失败,进入acquireQueued()
  3. A线程一直占用锁资源,则B线程调用tryAcquire()会一直失败
    /**
     * 该方法运行在独占非中断模式下
     * 1.为已经在AQS队列中的线程执行acquire
     * 2.为Condition.await()执行acquire(牵涉到Condition,日后分析)
     *
     * @param node the node
     * @param arg the acquire argument
     * @return {@code true} if interrupted while waiting
     */
    final boolean acquireQueued(final Node node, int arg) {
        //此时B线程进入该方法
        //根据addWaiter()可知,此时AQS队列中有两个节点,第一个结点为头结点,无意义;第二个结点为封装B线程的Node结点
        try {
            boolean interrupted = false;
            for (;;) {
                //此时p即为head
                final Node p = node.predecessor();
                //完成"当V唤醒一个线程时,将该线程从队列中移除"逻辑
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                //完成"挂起当前队列"逻辑
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

由上文场景可知,B一直无法获取锁资源,则需要挂起B线程,先分析下挂起当前线程是如何实现的.挂起当前线程由shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()两个方法完成

shouldParkAfterFailedAcquire()
方法名字为 判断当tryAcquire()失败时是否应该挂起当前线程,其实该方法的一些逻辑我也尚未完全明白,但可以假想为该方法都返回true

当shouldParkAfterFailedAcquire()返回true后,由于两个方法由&&连接,则继续执行parkAndCheckInterrupt()

parkAndCheckInterrupt()
根据该方法名字可知该方法进行挂起当前线程和检查是否中断的逻辑 
    /**
     * Convenience method to park and then check if interrupted.
     *
     * @return {@code true} if interrupted
     */
    private final boolean parkAndCheckInterrupt() {
        //利用LockSupport挂起当前线程
        LockSupport.park(this);
        return Thread.interrupted();
    }

执行到LockSupport.park(this)时B线程已经被挂起,此时acquireQueued()已经完成挂起当前线程,那当V唤醒一个线程时,将该线程从队列中移除又是如何完成的呢?什么时候B线程又会被唤醒呢?
后一个问题比较简单:B线程会在A线程调用release()时被唤醒
让我们先看下release()的实现

    /**
     * Releases in exclusive mode.  Implemented by unblocking one or
     * more threads if {@link #tryRelease} returns true.
     * This method can be used to implement method {@link Lock#unlock}.
     *
     * @param arg the release argument.  This value is conveyed to
     *        {@link #tryRelease} but is otherwise uninterpreted and
     *        can represent anything you like.
     * @return the value returned from {@link #tryRelease}
     */
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                //唤醒后续结点
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

由于AQS队列有一个无意义的头结点,所以头结点的下一个结点就是第一个被挂在AQS队列上的线程,unparkSuccessor(h)唤醒AQS队列上的结点.

release()比较简单,已经分析完毕,让我们回到acqurieQueued(),分析acquiredQueued()是如何实现当V唤醒一个线程时,将该线程从队列中移除的呢?

    final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    //tryAcquire(arg)成功,将被唤醒的结点移出AQS队列,return
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

在parkAndCheckInterrupt()中B线程被挂起,在A线程的release()中B线程被唤醒,则B线程继续执行,由于是在死循环中,则会继续执行if (p == head && tryAcquire(arg)),此时由于A线程已经释放锁资源,则B线程tryAcquire()成功,将被唤醒的结点移出AQS队列后return

总结

至此,AQS源码已大致分析完毕

  • AQS就是记录型信号量的Java语言实现
  • acquire()和release()分别对应PV操作,具体语义有子类实现tryAcquire(),tryRelease()确定
  • AQS的release()较为简单,大部分逻辑由acquire()实现
    • 当前线程加入队列中–>addWaiter()
    • 挂起当前线程–>acquireQueued()挂起当前线程前的代码
    • 当V唤醒一个线程时,将该线程从队列中移除–>acquireQueued()挂起当前线程后的代码

不足

  • 博客大体介绍AQS整体思路,每个方法的具体细节需要查看源码
  • 未分析Node.waitStatue的作用
  • 一直将AQS当做一个锁来进行分析,但是AQS语义由子类确定,可以实现计数器(CountDownLatch)等语义
  • 未分析AQS中公平模式,可中断模式和定时模式的实现方法,三种模式的实现分析见JUC-ReentrantLock源码分析
  • 未分析AQS的独占和共享模式.共享模式见JUC-CountDownLatch源码分析
【java】java JUC 同步器框架 AQS AbstractQueuedSynchronizer源码图文分析
九师兄
02-10 468
1.概述 AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。 2.AQS 核心思想 AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态.
JUC学习 - AbstractQueuedSynchronizer源码解读（AQS）（补）
TyuIn的博客
12-03 428
接上一篇博客 https://blog.youkuaiyun.com/qq_43605444/article/details/121705312?spm=1001.2014.3001.5501 3、release(int) 方法 release(int)方法是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。这也正是unlock()的语义，当然不仅仅只限于unlock()。下面是release()的源码： /** *
JUC同步器框架AbstractQueuedSynchronizer源码图文分析
weixin_30556959的博客
04-07 194
JUC同步器框架AbstractQueuedSynchronizer源码图文分析 前提 Doug Lea大神在编写JUC(java.util.concurrent)包的时候引入了java.util.concurrent.locks.AbstractQueuedSynchronizer，Abstract Queued Synchronizer，也就是"基于队列实现的抽象同步器"，一般我们称...
详解AbstractQueuedSynchronizer（AQS）源码
sosovo66的博客
02-18 556
上篇文章讲解了CountDownLatch源码，底层是继承了AQS基类调用父类和重写父类方法实现的，本文将简介AQS源码和架构设计，帮助我们更深入理解多线程实战。
【Java并发编程实战】-----“J.U.C”：AQS分析（一）
chenssy 的技术博客
12-17 6554
在前面博客中，LZ讲到了ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch，他们都有各自获取锁的方法，同时相对于Java的内置锁，他们具有明显的优势：花最小的空间开销创建锁、最少的时间开销获得锁、使用更加方便灵活。参考Java的内置锁，对于JUC同步器而言，他应该具备两个最基本的功能：获取锁，释放锁。其中获取锁应该是先判断当前
aqs源码
5431的专栏
11-27 324
博客地址 aqs AQS（AbstractQueuedSynchronizer）是JAVA中众多锁以及并发工具的基础，其底层采用乐观锁，大量使用了CAS操作， 并且在冲突时，采用自旋方式重试，以实现轻量级和高效地获取锁。 AQS虽然被定义为抽象类，但事实上它并不包含任何抽象方法。AQS是被设计为支持多种用途，如果定义抽象方法，子类在继承的时候就需要实现所有抽象方法，所以AQS将需要子类覆盖的方法都...
AQS源码
大龙的博客
12-04 185
一、前沿 AQS 全称是 AbstractQueuedSynchronizer，即 抽象队列同步器，它底层采用了 CAS 技术保证了操作的原子性，同时利用 FIFO 队列实现线程间的锁竞争。作为基础的功能->同步抽象到了 AQS 中，这也是 JDK 并发包中 ReentrantLock、CountDownLatch、Semaphore、ReentrantReadWriteLock 等同步工...
JUC AQS源码分析（上） -- AQS原理分析
淦淦淦！
01-26 648
该系列博客主要分为上中下三篇分别介绍：AQS框架的原理、ReentrantLock上锁源码解析、ReentrantLock解锁源码解析 一、介绍 由于synchronize关键字在jdk1.6之前为重量级锁效率很低，每次对线程进行操作都需要涉及操作系统层面，于是并发大佬 Doug Lea 设计了JUC包，将线程同步操作提升到jdk级别，最差也是jvm级别。 队列同步器 AbstractQueued...
JUC源码学习笔记1——AQS和ReentrantLock
xuhss_com的博客
07-11 258
一丶Lock 锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁可以防止多个线程同时访问共享资源（这种锁称为独占锁，排他锁）但是有些锁可以允许多个线程并发访问共享资源，比如读写锁 3.使用Lock的经典范式 获取锁的过程不要写在try中，避免获取锁失败最后finally释放其他线程持有的锁使用一个int成员变量state表示同步状态，内置的FIFO队列来完成资源的获取和线程的排队工作，支持独占也支持共享的获取同步状态。三个变量被volatile修饰，保证其线程可见性等待状态是一个枚举，具备下列可选的值
JUC AQS（AbstractQueuedSynchronizer）
12-28
ReentrantLock Lock 加锁过程源码分析图，AQS 源码分析
Java并发-AbstractQueuedSynchronizer（AQS）JDK源代码分析
li_xunhuan的博客
09-22 477
一、概要分析： 1.1 引子  学习Java并发编程不得不去了解一下java.util.concurrent这个包，这个包下面有许多我们经常用到的并发工具类，例如：ReentrantLock,CountDownLatch,CyclicBarrier, Semaphore等。而这些类的底层实现都依赖于AbstractQueuedSynchronizer这个类，由此可见这个类的重要性。所以在Java并...
AQS源码（jdk1.8）
Tezuka
04-04 752
AQS（AbustactQueuedSynchronizer）队列同步器是Java同步的基础组件，ReentrantLock，ReentrantReadWriteLock，CountDownLatch，CyclicBarrier，Semaphore等都是基于AQS来实现的，了解AQS的源码对于多线程编程还是有一些帮助，也可以实现自定义的同步组件。 AQS使用了模板方法设计模式，提供了独占锁/共享锁...
JUC之AQS
臻是二哥
07-27 365
[color=red]AQS是同步框架，它进行两个方面的工作：资源的管理和资源申请者的管理。[/color]对应由两部分组成：一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。state的访问方式有三种: [code="java"] getState() setState() compareAndSetState...
AQS源码（一）
weixin_44607702的博客
08-08 905
qq
AQS源码，你也可以
qq_52142181的博客
02-22 332
AQS源码，你也可以
AQS 源码详解
prefect_start的博客
04-09 1063
AQS 源码详解 1、可重入锁 可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的的内层方法会自动获取锁（前提是锁对象得是同一个对象），不会因为之前已经获取过还没释放而阻塞。 Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。 可重入锁的种类： 隐式锁：在使用的时候不需要去手动释放锁（即synchronized关键字使用的锁）默认是可重入锁。 显式锁：使用的时候需要去释放锁（即Lock）也有ReentrantLock
硬核：5W字17张高清图理解同步器框架AbstractQueuedSynchronizer
m0_67698950的博客
05-25 242
前提# 并发编程大师Doug Lea在编写JUC（java.util.concurrent）包的时候引入了java.util.concurrent.locks.AbstractQueuedSynchronizer，其实是Abstract Queued Synchronizer，也就是"基于队列实现的抽象同步器"，一般我们称之为AQS。其实Doug Lea大神编写AQS是有严谨的理论基础的，他的个人博客上有一篇论文《The java.util.concurrent Synchronizer Framewor
java JUC源码解读 详细
最新发布
02-25
<think>嗯，用户之前让我介绍过Java多线程的基础知识，现在他们想深入了解JUC（java.util.concurrent）的源码。这说明用户可能已经掌握了多线程的基本概念和使用方法，现在想更深入理解底层实现，提升自己的技术水平。 首先，我需要确定用户对JUC的了解程度。他们可能已经用过一些工具类，比如ReentrantLock或CountDownLatch，但现在想了解这些类内部的机制。用户可能是中高级开发者，希望优化代码性能，或者准备面试，需要深入理解并发框架。 接下来，我需要考虑如何组织内容。直接深入源码可能会让用户感到困惑，所以应该先从JUC的整体结构入手，然后分模块解析核心类。比如，原子类、锁、同步器、并发集合、线程池等，每个部分都需要挑选关键点进行讲解。 用户可能需要知道关键设计模式，比如AQS（AbstractQueuedSynchronizer），因为这是JUC的核心。需要详细解释AQS的工作原理，如CLH队列、状态管理等。此外，CAS操作和volatile关键字也是实现无锁并发的基础，需要结合源码说明它们的作用。 另外，用户可能对常见类的实现感兴趣，比如ReentrantLock的公平锁与非公平锁区别，ConcurrentHashMap的分段锁或CAS优化，线程池的任务调度流程等。需要结合代码示例和流程图，帮助用户理解这些复杂机制。 同时，要注意避免过于冗长的代码展示，而是聚焦在关键方法和设计思路上。例如，AQS的acquire和release方法，以及它们如何被ReentrantLock或Semaphore调用。此外，可以比较不同版本的实现变化，比如JDK1.7和1.8中ConcurrentHashMap的改进，让用户了解优化方向。 最后，需要给出学习建议，推荐用户如何逐步深入源码，比如从简单的AtomicInteger开始，再逐步研究AQS和锁的实现。同时，提醒用户注意调试和测试的重要性，通过实际案例加深理解。 总结下来，回答的结构应该是先概述JUC的重要性，再分模块解析核心源码，结合关键设计模式和具体类实现，最后给出学习方法和资源推荐。这样既系统又深入，帮助用户由浅入深地掌握JUC源码。</think>好的！`java.util.concurrent`（JUC）是 Java 并发编程的核心工具包，包含大量高性能、线程安全的工具类和框架。深入源码理解其设计思想，能帮助你掌握高并发编程的精髓。以下从 **核心模块**、**设计模式**、**关键类源码分析** 三个维度进行详细解读。 --- ### **一、JUC 整体架构** JUC 的核心模块包括： 1. **原子类**（Atomic）：基于 CAS 的无锁并发操作（如 `AtomicInteger`）。 2. **锁与同步器**（Locks）：如 `ReentrantLock`、`AQS`（AbstractQueuedSynchronizer）。 3. **并发容器**（Collections）：如 `ConcurrentHashMap`、`CopyOnWriteArrayList`。 4. **线程池**（Executors）：`ThreadPoolExecutor`、`ForkJoinPool`。 5. **同步工具**（Tools）：`CountDownLatch`、`CyclicBarrier`、`Semaphore`。 6. **并发流与 Future**：如 `CompletableFuture`、`ForkJoinTask`。 --- ### **二、核心源码解读** #### **1. AQS（AbstractQueuedSynchronizer）** AQS 是 JUC 锁和同步器的基石（如 `ReentrantLock`、`Semaphore` 均基于它实现）。 ##### **核心设计** - **状态变量（state）**：通过 `volatile int state` 表示资源状态（如锁的持有次数）。 - **CLH 队列**：一个双向链表实现的等待队列，存储竞争资源的线程。 - **模板方法模式**：子类只需实现 `tryAcquire`/`tryRelease`，AQS 负责线程排队和唤醒。 ##### **源码关键方法** ```java // 独占模式获取资源（如 ReentrantLock.lock()） public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } // 子类需实现 tryAcquire（如判断 state 是否为0） protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); } ``` ##### **实现示例：ReentrantLock 的公平锁** ```java // 公平锁的 tryAcquire 实现 protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && // 关键：检查队列是否有等待线程 compareAndSetState(0, acquires)) { // CAS 更新状态 setExclusiveOwnerThread(current); return true; } } // 处理重入逻辑（state 增加） else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; setState(nextc); return true; } return false; } ``` --- #### **2. 原子类（AtomicInteger）** 原子类的核心是 **CAS（Compare-And-Swap）** 操作，直接依赖 CPU 指令（如 x86 的 `cmpxchg`）。 ##### **源码关键实现** ```java public class AtomicInteger extends Number implements java.io.Serializable { private volatile int value; // 通过 volatile 保证可见性 public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); } } // Unsafe 类的 CAS 操作（native 方法） public final class Unsafe { public final native boolean compareAndSwapInt( Object o, long offset, int expected, int x); } ``` ##### **CAS 的 ABA 问题** - **问题**：变量从 A 改为 B 又改回 A，CAS 无法感知中间变化。 - **解决方案**：使用 `AtomicStampedReference` 添加版本号。 --- #### **3. ConcurrentHashMap（JDK 1.8）** JDK 1.8 摒弃分段锁，改用 **CAS + synchronized** 实现更细粒度的锁。 ##### **关键设计** - **Node 数组（table）**：每个桶位（bucket）是一个链表或红黑树。 - **并发控制**： - **CAS 初始化数组**：避免多线程重复初始化。 - **synchronized 锁桶头节点**：仅锁定单个桶，减少竞争。 ##### **putVal 方法核心逻辑** ```java final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException(); int hash = spread(key.hashCode()); int binCount = 0; for (Node<K,V>[] tab = table;;) { Node<K,V> f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); // CAS 初始化数组 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value))) break; // CAS 插入新节点 } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); // 协助扩容 else { synchronized (f) { // 锁住桶头节点 // 插入链表或红黑树 } } } } ``` --- #### **4. ThreadPoolExecutor** 线程池的核心是 **任务队列** 和 **线程调度策略**。 ##### **核心参数** - **corePoolSize**：核心线程数（即使空闲也不销毁）。 - **workQueue**：任务队列（如 `LinkedBlockingQueue`）。 - **RejectedExecutionHandler**：拒绝策略（如丢弃、抛异常）。 ##### **execute 方法逻辑** ```java public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) // 创建新线程执行任务 return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { // 任务入队 // 二次检查线程池状态 } else if (!addWorker(command, false)) // 尝试创建非核心线程 reject(command); // 触发拒绝策略 } ``` --- ### **三、JUC 设计模式与技巧** 1. **CAS 无锁编程** - 通过 `Unsafe` 类直接操作内存，避免锁竞争（如原子类、ConcurrentHashMap）。 - 适用场景：读多写少，竞争不激烈。 2. **模板方法模式** - AQS 将公共逻辑（如线程排队）抽象到基类，子类只需实现特定方法（如 `tryAcquire`）。 3. **写时复制（Copy-On-Write）** - `CopyOnWriteArrayList` 在修改时复制整个数组，保证读操作无锁。 4. **分段锁优化** - JDK 1.7 的 `ConcurrentHashMap` 使用分段锁（Segment），减少锁粒度。 --- ### **四、高频源码面试题** 1. **AQS 的 CLH 队列为什么是双向链表？** - 答：为了支持取消操作（如超时或中断），需要快速定位前驱节点。 2. **ConcurrentHashMap 1.7 和 1.8 的区别？** - 1.7：分段锁 + ReentrantLock； - 1.8：CAS + synchronized + 红黑树。 3. **线程池如何回收空闲线程？** - 答：`ThreadPoolExecutor` 通过 `getTask()` 中的 `poll(keepAliveTime)` 实现超时回收。 --- ### **五、学习建议** 1. **调试源码**：通过 IDE 调试 `ReentrantLock.lock()` 的执行流程。 2. **阅读注释**：JUC 类的源码注释通常包含设计思路和并发规则。 3. **手写简化版**：尝试实现一个简单的 AQS 或线程池。 理解 JUC 源码不仅能提升并发编程能力，还能深入掌握 Java 的高性能设计哲学。建议从 `AtomicInteger` 和 `ReentrantLock` 入手，逐步扩展到复杂类如 `ConcurrentHashMap` 和 `ThreadPoolExecutor`。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值