AQS 的 state 和 ConcurrentHashMap 的 sizeCtl,本质是同一个东西

Java 8 ConcurrentHashMap底层原理与源码级深度解析 在并发编程中,并发容器是保障多线程安全与性能的核心工具。ConcurrentHashMap作为Java并发包中的代表,其底层实现从Java 7的分段锁演进为Java 8的CAS+synchronized机制,结合数组、链表与红黑树结构,在保证线程安全的同时大幅提升了并发度。理解其散列扰动、锁粒度控制、扩容协作流程,对排查并发场景下的性能瓶颈和隐藏bug至关重要。无论是高频读写缓存、实时统计计数,还是分布式组件中的共享Map,掌握它的设计思想都能帮助开发者写出更健壮的代码。本文从数据结构、put/get流程、 阅读详情

AQS 的 state 和 ConcurrentHashMap 的 sizeCtl,本质是同一个东西

面试题经常把 AQS、ConcurrentHashMap、对象头分开问,好像它们是三个独立的知识点。

但如果你把源码摆在一起看,会发现它们用的是同一个套路:用一个 volatile 的 int 记录状态,用 CAS 去改它,改不动就排队等着。

理解了这一句,三个东西就不再是硬背的知识点,而是同一个思路的三种应用。
在这里插入图片描述

一、AQS:一个 state 加一条队列

AbstractQueuedSynchronizer 这个名字很唬人,但它的核心就两个字段:

public abstract class AbstractQueuedSynchronizer {
    private volatile int state;              // 状态
    private transient volatile Node head;    // 队列头
    private transient volatile Node tail;    // 队列尾
}

没了。就这么多。

state 的含义,由子类定义

这是 AQS 设计上最巧的一点:它自己不给 state 赋予语义,全靠子类解释。

实现类state 表示什么
ReentrantLock重入次数。0 = 未锁,1 = 锁了一次,2 = 重入了
Semaphore剩余许可数
CountDownLatch还剩几个任务没完成
ReentrantReadWriteLock高 16 位读锁数,低 16 位写锁数

所以 AQS 提供的是"排队机制",不是"锁语义"。语义由子类通过 tryAcquire / tryRelease 自己实现。

抢不到锁的线程去哪了

进 CLH 队列排队,然后 park 挂起。

流程(以 ReentrantLock.lock() 为例):

lock()
  → tryAcquire(state)       // 子类实现,尝试 CAS 改 state
      ├─ 成功 → 直接返回,不进队列
      └─ 失败
          → addWaiter()     // 包装成 Node,插到队尾
          → acquireQueued() // 自旋 + park
              ├─ 前驱是 head 且 tryAcquire 成功 → 出队,成为新 head
              └─ 否则 park 挂起

acquireQueued 里有个细节:只有前驱节点是 head 的线程才会去尝试抢锁,其它节点老老实实 park。这样避免了所有等待线程同时被唤醒又同时失败的"惊群"。

释放时:

unlock()
  → tryRelease()            // state 减到 0
  → unparkSuccessor(head)   // 只唤醒队列里的下一个

独占 vs 共享

AQS 支持两种模式,区别在"抢到之后要不要把资源让出来":

独占模式:同一时刻只有一个线程能持有。

  • tryAcquire / tryRelease
  • ReentrantLock

共享模式:多个线程可以同时持有。

  • tryAcquireShared / tryReleaseShared
  • Semaphore、CountDownLatch
  • ReadWriteLock 的读锁

共享模式的传播特性很有意思:一个线程抢到共享资源后,会继续唤醒后面的共享节点,因为资源还有剩余。

公平锁和非公平锁,差在哪一行

// 非公平锁
final void lock() {
    if (compareAndSetState(0, 1))      // 先抢一次,不管有没有人排队
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

// 公平锁
final void lock() {
    acquire(1);                         // 直接走 acquire,会检查队列
}

非公平锁在入队之前,会先 CAS 抢一次。 如果刚好这一刻锁释放了,它就能插队成功。

这是非公平锁吞吐量更高的原因——减少了线程唤醒和上下文切换。代价是可能"饿死"队列里的线程(概率很低,因为要恰好撞上释放的瞬间)。

tryAcquire 里还有一处区别:公平锁会多判断一个 hasQueuedPredecessors(),队列里有人排队就不抢。

二、ConcurrentHashMap:锁最小的那一块

JDK 7 和 JDK 8 的实现差别很大,面试基本都会问"为什么要改"。

JDK 7:Segment 分段锁

final Segment<K,V>[] segments;   // 默认 16 段

每个 Segment 继承 ReentrantLock,锁的粒度是"一段"。理论并发度是 16。

问题:内存开销大(每个 Segment 都是一整个 HashMap 结构),而且 16 这个数字写死了,扩容也不方便。

JDK 8:CAS + synchronized 锁桶头

transient volatile Node<K,V>[] table;    // 就是一个 Node 数组

锁的粒度降到单个桶的头节点。并发度等于数组长度(默认 16,可以扩到很大)。

关键变化:用 synchronized 而不是 ReentrantLock。

原因有两个:

  1. synchronized 在 JDK 6 之后有偏向锁/轻量级锁优化,无竞争时开销极低
  2. 锁的只是"一个桶的插入操作",临界区极短,重量级锁的膨胀风险很小

put 的四个分支

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // ① 表为空 → CAS 设置 sizeCtl,initTable
    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;
    }

    // ③ 桶头 hash == MOVED(-1) → 正在扩容,帮着搬
    else if ((fh = f.hash) == MOVED)
        tab = helpTransfer(tab, f);

    // ④ 桶有节点 → synchronized 锁住头节点
    else {
        synchronized (f) {
            // 链表插入 或 红黑树插入
        }
    }
}

四个分支对应四种并发场景,这就是它比 Hashtable 快两个数量级的原因——Hashtable 是整张表一把锁。

扩容:多线程一起搬

这是 JDK 8 最精妙的地方。扩容不是一个人搬,是所有写线程一起搬。

  • sizeCtl 为负数时,表示正在扩容。高 16 位是扩容戳,低 16 位是参与线程数
  • 每个线程领一个区间(stride),搬完了就继续领下一个
  • 搬完的桶放一个 ForwardingNode(hash = MOVED),别的线程看到就知道"这个桶搬过了"

所以 sizeCtl 这个字段同时承担了三件事:初始化阈值、扩容阈值、扩容状态。这也是它必须是负数才能表示"扩容中"的原因。

size 是怎么算的

private transient volatile long baseCount;
private transient CounterCell[] counterCells;

直接用一个 AtomicLong 在高并发下会成为热点(所有线程抢同一个 CAS)。所以用了分段计数:

  • 无竞争:直接 CAS 改 baseCount
  • 有竞争:分配一个 CounterCell,各自累加
  • 求和:baseCount + 所有 CounterCell 的值

这跟 LongAdder 是同一个思路。

为什么不允许 null 键和 null 值

HashMap 允许,ConcurrentHashMap 不允许。

原因是并发下的二义性:get(key) 返回 null,你无法区分"这个 key 不存在"还是"这个 key 存在但值是 null"。

单线程下可以 containsKey 再判断,但并发下这两步之间状态可能变了。所以直接禁止 null,让 get 返回 null 就等价于"不存在"。

三、4 字节的 ClassPointer 为什么够用

这一节讲对象头,很多人不知道它和上面有什么关系——其实关系很大:压缩指针是"用位运算换内存",和 AQS 用 state 换锁,是同一种思路。

64 位 JVM 下的对象头

| Mark Word (8 字节) | Klass Pointer (4 或 8 字节) | 实例数据 | 对齐填充 |

Klass Pointer 指向方法区里的类元数据。64 位下本来要 8 字节。

压缩原理:低 3 位是白送的

JVM 要求对象起始地址按 8 字节对齐(因为要配合 CPU 缓存行)。

这意味着任何对象地址的低 3 位都是 0:

地址: 0x0000_0001_2345_6788
                              ↑↑↑ 永远是 000

既然这三位永远是 0,存的时候就可以省掉。压缩后的 4 字节存的是"地址除以 8":

存储值 = 真实地址 >> 3
还原   = 存储值 << 3

4 字节 = 32 位,能表示 2³² 个"8 字节单位" = 32GB。

32GB 魔咒

堆一旦超过 32GB,4 字节装不下所有地址,压缩自动失效,指针变回 8 字节。

结果:

  • 每个对象的引用字段变大 → 对象变大 → 同样的数据占更多内存
  • 缓存命中率下降 → 性能反而更差

所以 JVM 调优有一条经验:堆要么小于 32GB,要么远大于(比如 48GB、64GB),别卡在 32~48 之间。

相关参数:

-XX:+UseCompressedOops           # 压缩对象引用(默认开启)
-XX:+UseCompressedClassPointers  # 压缩 Klass Pointer(默认开启)
-XX:ObjectAlignmentInBytes=8     # 对齐字节数,改成 16 可以让 4 字节省到 64GB

最后那个参数很少人知道:把对齐从 8 改成 16,压缩指针的寻址范围就翻倍到 64GB。代价是对象内部可能有更多填充浪费。

怎么确认是否生效:

java -XX:+PrintFlagsFinal -version | grep UseCompressedOops

四、三个东西的同一个思路

把这三节摆在一起看:

记录状态的字段怎么改改不动怎么办
AQSstate(int)CAS进 CLH 队列 park
ConcurrentHashMapsizeCtl(int)CAS帮着扩容 / 锁桶头
压缩指针地址 >> 3(int)位运算——

前两个是同一个模板:一个 volatile int 当状态位,CAS 当乐观锁,失败才走悲观路径。

这个模板的好处是:绝大多数情况下(无竞争)只花一次 CAS 的代价,不需要真正加锁。

这也是为什么 ConcurrentHashMap 读操作完全不加锁(get 只读 volatile),写操作只在桶冲突时才 synchronized。

面试怎么答

如果被问"AQS 原理",别一上来背 acquire 流程。先说这一句:

AQS 是一个基于 volatile int state 和 CLH 双向队列的同步框架。state 的语义由子类定义,AQS 只负责"抢不到就排队、释放就唤醒"这套机制。

然后再展开 tryAcquire、addWaiter、park/unpark。这个顺序能让面试官立刻知道你懂的是设计,不是流程。

如果被问"ConcurrentHashMap 为什么快",重点说三句:

  1. 锁粒度从"整表"降到"单个桶头"
  2. 读操作完全无锁(volatile 读)
  3. 扩容支持多线程协作,不是一个人搬

这一节对应课程 1-6「AQS 到底是啥」、1-9「ConcurrentHashMap 的…」和 1-8「Java 中 4 字节的 ClassPointer」,三节连起来看,正好能把"并发 + JVM 内存布局"这条线串通。
在这里插入图片描述

想要这套笔记 + 源码调试记录的,扫码加我,备注「Java」👇
在这里插入图片描述

不用转发、不用关注,加上直接发你。

Java并发编程面试核心原理精讲:从synchronized到AQS 并发编程是Java后端开发的核心技能,也是面试中容易拉开差距的环节。从CPU缓存与内存模型出发,理解可见性、原子性与有序性是掌握并发底层逻辑的基础。JMM定义了线程间共享变量的通信规则,volatile通过内存屏障保证可见性与禁止重排序,而synchronized则借助对象头Mark Word实现锁升级,从偏向锁到重量级锁的演进体现了对竞争场景的深度优化。进一步深入JUC工具包,CAS无锁算法与AQS抽象队列同步器构成了ReentrantLock、Semaphore等同步器的基石。线程池作为生产环境最常用的 阅读详情

相关推荐

Java并发编程:CAS原理、应用与面试解析

CAS(Compare-And-Swap)作为并发编程的核心机制,通过CPU原子指令实现无锁线程安全操作,是理解Java内存模型(JMM)和并发控制的重要入口。其原理基于硬件层面的原子操作(如x86的cmpxchg指令)和JMM的happens-before规则,配合volatile变量和内存屏障确保可见性。在Java中,Unsafe类提供的CAS操作是JUC包的基础,广泛应用于AtomicInteger、AQS等并发工具。CAS技术价值在于其高性能的无锁特性,特别适合低竞争场景,相比传统锁机制能显著提升吞

weixin_33816821的博客 615

Java 8 ConcurrentHashMap源码详解:从CAS无锁读到多线程扩容机制

在并发编程中,线程安全的哈希表是解决多线程数据共享的核心工具。从早期的Hashtable到Collections.synchronizedMap,锁竞争始终是性能瓶颈。Java 8的ConcurrentHashMap通过CAS、volatile与synchronized的巧妙组合,实现了读操作近乎无锁、写操作仅锁桶头节点的细粒度并发控制。其底层采用数组+链表+红黑树结构,配合多线程协助扩容机制,将并发能力从固定分段提升至与数组长度相关,极大地优化了高吞吐场景下的响应速度。无论是应对热点Key倾斜、缓存统计,

weixin_34396902的博客 455

【一线大厂Java面试题合集】第09篇-ConcurrentHashMap源码深度剖析

1. key/value 非空检查(ConcurrentHashMap 不允许 null)2. 计算 hash(spread扰动)3. 循环(自旋):a. table 未初始化 → initTable()(CAS 初始化)b. 桶为空 → CAS 插入空节点c. 桶头 hash==MOVED → 协助扩容 helpTransfer()d. 桶非空 → synchronized 锁头节点- 链表:遍历,覆盖或尾插- 红黑树:putTreeVal。

gaochufukanyongren的博客 156

JUC并发编程地图:从AQS到线程池的实战避坑指南

在Java并发编程实战中,JUC是一套围绕线程安全与任务调度构建的工具体系。其底层依赖JMM的happens-before规则与CAS无锁机制,并通过AQS统一管理同步状态和等待队列。理解这套原理,能帮助开发者在高并发场景下正确选用ReentrantLock、信号量、并发容器与线程池,避免死锁、可见性与资源耗尽问题。面对老项目里混杂的同步手段,系统梳理JUC的依赖地图,比死记API更有效。从AQS到线程池,沿着地基、零件、组装的学习路径,可以逐步建立稳定可交付的并发编程能力。

weixin_34268753的博客 488

python毕设 基于Web的中药材信息查询系统程序+论文

***(程序+源码+数据库+调试部署+开发环境)论文文档1,文末可获取,系统界面在最后面。****

m0_74825541的博客 1257

AD56XXR系列DAC驱动设计:SPI接口、寄存器配置与嵌入式工程实践

数模转换器(DAC)是嵌入式系统实现高精度模拟控制的核心器件,其性能取决于通信协议可靠性、寄存器配置准确性及硬件协同设计能力。基于SPI总线的电压输出型DAC广泛应用于工业控制、光模块偏置、传感器校准等场景,需兼顾静态精度、动态响应与低功耗特性。AD56XXR系列作为典型集成内部基准与多通道同步更新能力的12/14/16位DAC,支持轨到轨输出与灵活掉电模式,为资源受限MCU提供可移植固件范式。本文围绕SPI时序约束、16位指令字解析、LDAC同步机制及精度补偿策略展开,覆盖从硬件连接、初始化流程到量产级可

weixin_33481022的博客 612

ConcurrentHashMap深度解析:从线程安全到高并发设计

在Java多线程编程中,线程安全容器是解决共享数据竞争的关键。ConcurrentHashMap作为J.U.C包的核心组件,通过CAS、synchronized和volatile等机制,实现了高并发读、适度并发写和弱一致性。其底层采用数组+链表+红黑树结构,锁粒度细化到桶级别,显著提升了并发性能。理解其设计原理,有助于在缓存、计数器等场景中正确选型,避免数据覆盖、死循环等常见问题。

weixin_33906657的博客 175

C#实战:如何用TSCLIB.dll实现TSC打印机的状态监控与异常处理(附完整代码)

本文详细介绍了如何利用C#和TSCLIB.dll构建企业级TSC打印机状态监控与智能异常处理系统。通过解析十六进制状态码、设计高可靠性的轮询引擎以及实现事件驱动的报警机制,开发者可以打造一个稳定、可观测的打印服务,有效保障物流仓储、生产制造等高频打印场景的业务连续性。

weixin_29227585的博客 64

JDK 8 ConcurrentHashMap源码深度解读:锁、CAS与并发扩容

在Java并发编程中,线程安全的Map实现经历了从Hashtable的全局锁到分段锁的长期演进。JDK 8的ConcurrentHashMap彻底放弃分段锁,将锁粒度细化到单个哈希桶头节点,并借助CAS、volatile与synchronized的组合,实现了完全无锁的读操作和高效的并发写入。文章从源码层面剖析其数据结构、put/get流程、并发扩容协作以及size()计数设计,解释了为什么读无需加锁、put为何锁桶头、扩容时其他线程如何协助,以及LongAdder思想如何应用于计数。理解这些机制,对于应对

weixin_33462167的博客 211

强化学习(Reinforcement Learning)与动态系统控制方法

一个具体的 RBC 的例子是自动驾驶汽车中的交通规则。在训练过程中,代理通过与环境交互获取奖励信号,并学习如何在某个状态下采取最佳的行动,以最大化长期的累积奖励。在化工过程中,通过对生产过程中的温度、压力、流量等参数的控制来实现产品的质量和产量的提高。需要注意的是,以上代码只是一个简单的示例,实际的 MPC 系统可能会更加复杂,并包含更多的模型预测和控制算法来实现更复杂的控制任务。需要注意的是,以上代码只是一个简单的示例,实际的自动驾驶汽车系统可能会更加复杂,并包含更多的规则和条件来确保安全行驶。

AI天才研究院 4066

Spring AI Alibaba实战训练营-14基于A2A协议智能体应用开发指南

本文介绍了基于A2A协议的智能体应用开发流程,主要包括客户端和服务端两个模块的实现。关键技术包括A2A通信协议、Nacos服务发现、Spring AI Alibaba框架和DashScope通义千问API。开发步骤涵盖环境准备(JDK17、Maven、Nacos)、项目创建、依赖配置(重点引入spring-ai-alibaba相关组件)以及Nacos和DashScope的核心配置。整个系统架构采用客户端通过Nacos发现服务端Agent,再调用阿里云AI服务的模式,实现了AI能力的解耦与复用。

program哲学 507

Java并发编程与堆算法实战指南

并发编程是Java开发中的核心技术,JUC(java.util.concurrent)包提供了强大的并发工具集,包括线程安全的ConcurrentHashMap、基于AQS的锁机制以及灵活的线程池实现。堆算法作为数据结构的重要分支,在优先级队列、Top K问题等场景有广泛应用。理解CAS操作、CLH队列等底层原理,掌握堆的插入删除时间复杂度分析,能有效解决实际开发中的并发控制与性能优化问题。本文通过ConcurrentHashMap的putVal实现、PriorityQueue的堆调整等代码示例,演示如何应

weixin_30500473的博客 400

SAR合成孔径雷达成像及处理(附带Matlab源代码)

总结:本文介绍了SAR合成孔径雷达的基本原理,并提供了使用Matlab实现SAR成像和处理的源代码示例。然后,在慢时间域进行方位压缩处理,通过计算每个接收通道的延迟和频移,将多次接收的信号叠加得到最终的成像结果。SAR成像的基本原理是通过接收雷达发射的脉冲信号的回波,并利用多次接收的信号进行叠加处理。以多普勒频移校正为例,根据雷达飞行速度和方位角,计算实际的多普勒频率,并对每个接收通道的数据进行频移校正,以消除因目标运动引起的频率偏移。通过调整参数和算法,可以实现不同的SAR成像和处理效果。

ByteJolt的博客 691

并发编程知识体系

本文摘要: 锁机制对比:共享锁/排他锁关注兼容性,乐观锁/悲观锁是并发处理策略,各有适用场景。 线程池配置:基于CPU核心数和任务类型(I/O或计算密集型),通过公式初算后结合监控调优。 单核CPU并发问题:仍存在可见性(寄存器缓存)、原子性(线程切换)和有序性(指令重排)问题。 缓存机制:缓存一致性协议(MESI)保证数据一致性,缓存锁基于协议实现原子操作,两者目标不同但协同工作。 synchronized锁升级:根据竞争强度自适应升级(无锁→偏向锁→轻量级锁→重量级锁)

weixin_47626220的博客 219

Python 爬虫实战:社交媒体(Facebook)评论数据抓取与情感分析

在当今数字化时代,社交媒体平台如 Facebook 已成为人们日常生活中不可或缺的一部分。它不仅是人们分享生活点滴、交流思想的场所,也为企业和研究人员提供了丰富的数据资源。通过分析社交媒体上的评论数据,我们可以了解用户的情感倾向、产品反馈以及社会热点话题等。本文将详细介绍如何使用 Python 爬虫技术抓取 Facebook 上的评论数据,并进行情感分析。这不仅是一次技术实战,更是一次数据探索之旅。

yansideyucsdn的博客 673

基于物联网技术设计的微型消防小车控制系统(STM32+ESP8266局域网)(181)

基于物联网技术的小微型消防车控制系统。通过远程控制功能,用户能够灵活操作消防车的行驶,方便快速抵达火灾现场。环境感知功能实时采集烟雾浓度、温湿度信息,为灭火决策提供科学依据。火源定位功能采用自动和手动两种模式,准确迅速地定位火源,并通过报警提示用户。灭火功能则根据火源定位结果,自动或手动启动干粉灭火器进行高效灭火。这些功能的结合实现了对小型火灾的全面应对,提升了消防效率与安全性,减少了火灾带来的损失。通过本项目的设计与实现,为消防领域提供了一种创新且实用的解决方案。

3084

Java高并发面试核心考点与实战解析

并发编程是Java高级开发的核心能力,其本质在于解决多线程环境下的资源共享与协调问题。从JVM内存模型到CPU缓存一致性协议,底层原理决定了synchronized、volatile等关键字的语义。Java并发工具包(JUC)基于AQS框架构建,提供了ReentrantLock、CountDownLatch等经典工具,大幅提升了并发控制能力。在高并发系统设计中,线程池参数调优和锁粒度控制直接影响吞吐量,如IO密集型任务推荐使用2N线程数配置。典型应用场景包括秒杀系统的分层削峰、ConcurrentHashM

weixin_30252709的博客 338

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

深入拆解JDK1.8 ConcurrentHashMap:桶级锁、CAS与多线程扩容

在Java并发编程中,如何保证哈希容器线程安全是核心挑战之一。JDK1.8的ConcurrentHashMap摒弃了1.7的Segment分段锁,改用CAS无锁插入与synchronized桶级锁,将锁粒度降至单个哈希桶,并通过volatile字段实现无锁读。它引入的多线程协作扩容与ForwardingNode机制,以及基于LongAdder的分段计数,显著提升了高并发场景下的性能和扩展性。这类设计广泛用于缓存框架、消息中间件和业务系统。掌握其原理,不仅是面试加分项,更有助于解决线上锁竞争与热点问题。

weixin_31960565的博客 57

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Java并发编程实战:JUC核心组件与高并发优化

并发编程是现代Java开发的核心技能,JUC(Java Util Concurrent)作为Java官方并发工具包,提供了原子变量、锁机制、并发集合等关键组件。其底层通过CAS(Compare-And-Swap)实现无锁编程,结合AQS(AbstractQueuedSynchronizer)框架构建了高效的同步机制。在高并发系统中,合理使用ReentrantLock、ConcurrentHashMap等组件可显著提升吞吐量,避免死锁问题。典型应用场景包括秒杀系统、实时交易等需要线程安全与高性能并存的领域。通

weixin_30315905的博客 315

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

leetcode 算法题库:4000+ 道多语言面试题解,一次覆盖 4 大经典题库

打开这个仓库,你首先看到的是一摞按题号命名的目录:每道 LeetCode 题一个文件夹,里面是题目描述、多份语言的解法代码和时间空间复杂度分析。这就是 leetcode 多语言算法题解项目的全部形态——4095 道 LeetCode 题、119 道《剑指 Offer(专项突击版)》、109 道《程序员面试金典(第 6 版)》、70+ 道《剑指 Offer(第 2 版)》面试题,几乎每题都有 Jav

gitblog_00085的博客 492

Kazumi 番剧采集完整指南:从快速安装到自定义规则一次讲清

Kazumi 是一款免费的开源番剧采集工具,基于 Flutter 开发,移动端和桌面端都能跑。它不内置固定片库,而是让你用自定义规则把各类动漫网站接进来,再配上弹幕互动、追番记录和实时超分,搭一个完全属于自己的播放器。 ## 🎯 为什么值得装:先看卖点再看设备 卖点浓缩成三条:视频源由你自己定、支持弹幕互动、内置 Anime4K 实时超分。愿意花十分钟写一条规则的人,它是最对路的选择;不想折

gitblog_00146的博客 313

【Java面试】——Java 基础与并发编程

Java基础面试

u013430575的博客 195

Java高并发面试核心考点与实战技巧解析

并发编程是Java核心技术中的重要领域,其核心在于通过多线程机制提升系统吞吐量。从JUC工具包到锁优化策略,开发者需要理解内存可见性、原子操作等底层原理。在实际工程中,线程池参数配置、并发容器选型直接影响系统性能,比如ConcurrentHashMap的分段锁优化可提升10倍吞吐量。高并发场景如秒杀系统需结合缓存预热、异步处理等技术,通过Redis+Lua实现分布式锁可达到2万+ QPS。面试中常考察的AQS实现、CAS原理等知识点,正是分布式系统、实时交易等场景的技术基础。掌握这些并发编程的核心思想,能够

weixin_30357231的博客 448

J.U.C(java.util.concurrent)

Java是单继承的方式,继承Thread类以后,无法再继承其他类,存在局限性 无返回值 匿名内部类写法 子类写法 2. Runnable配合Thread 实现Runnable接口,重写run方法,创建Runnable实现类对象,并作为参数传入Thread构造方法中 匿名内部类写法 子类写法 上述两种实现方式没有返回值FutureTask实现RunnableFuture接口,该接口继承Runnable和Future接口,Future接口提供异步计算的核心方法,FutureTask接口内部维护一个outcome

m0_37949220的博客 406

Java面试高频考点深度解析:从集合、并发到JVM与Spring核心

在Java技术体系中,集合框架、并发编程、JVM内存管理和Spring框架是构建高可用、高性能应用的核心基础。理解HashMap的数组+链表/红黑树结构及其扩容机制,是掌握数据结构与算法在工程中应用的关键;而深入synchronized的锁升级过程和AQS(AbstractQueuedSynchronizer)原理,则是解决高并发场景下线程安全问题的基石。这些底层原理共同支撑了现代分布式系统的开发,尤其在面试场景中,对HashMap和ConcurrentHashMap的线程安全实现、JVM垃圾回收机制以及S

weixin_34068198的博客 540

Java面试八股文核心考点与实战技巧解析

Java面试中的八股文考察是评估开发者基本功的重要方式,涉及JVM内存模型、并发编程、Spring框架等核心技术。理解HashMap扩容机制、synchronized锁升级等原理,不仅能应对面试,更能提升实际工程能力。在分布式系统和高并发场景下,掌握这些基础知识有助于解决缓存雪崩、线程安全等典型问题。本文结合大厂面试真题,详解JVM调优、ConcurrentHashMap实现等高频考点,并分享STAR-L法则等结构化回答技巧,帮助开发者系统化备战。

weixin_33804582的博客 311
上一篇: 一次查询过了四道缓存,最后发现事务根本没生效
下一篇: 从容器启动到注册成功,Nacos 客户端到底发了什么
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值