基础知识 分类

Arthas是阿里巴巴开源的Java诊断工具，支持在线排查问题、性能分析、类热更新等，是生产环境必备的诊断利器。
本文系统介绍Arthas的核心功能和实战案例，帮助你快速定位和解决线上问题。

一、Arthas简介

1.1 核心能力

功能	说明
实时监控	方法执行耗时、调用次数
堆栈追踪	查看方法调用链路
反编译	动态查看class源码
类热更新	运行时修改class
线程分析	死锁检测、线程状态
内存分析	堆转储、对象统计
OGNL表达式	运行时执行任意代码

郑天祺2026/8/19大约 6 分钟

CompletableFuture异步编程完全指南

CompletableFuture是Java 8引入的异步编程工具，支持链式调用、组合、异常处理，是现代Java异步编程的核心。
本文系统介绍CompletableFuture的核心API、使用场景和实战案例，帮助你掌握异步编程的精髓。

一、异步编程演进

1.1 Java异步编程方式对比

方式	特点	缺点
Thread	基础线程	手动管理，无返回值
Runnable/Callable	定义任务	需要手动执行
Future	获取结果	阻塞等待，无链式
CompletableFuture	异步+链式	功能强大

郑天祺2026/8/19大约 5 分钟

G1与ZGC：现代垃圾收集器详解

G1和ZGC是当前最主流的两款低延迟垃圾收集器，理解它们的设计理念和调优方法是Java架构师的必备技能。
本文深入对比G1与ZGC的实现原理、适用场景和调优实战，帮助你做出正确的技术选型。

一、垃圾收集器演进历史

时间线：
1999年 → Serial (单线程)
2002年 → Parallel (多线程，吞吐量优先)
2004年 → CMS (并发标记清除，低停顿)
2010年 → G1 (分区收集，可预测停顿)
2018年 → ZGC (染色指针，亚毫秒停顿)
2021年 → Shenandoah (低停顿，并发压缩)

郑天祺2026/8/19大约 5 分钟

JVM内存模型深度解析：从原理到调优实战

JVM内存模型是Java性能调优的基石，理解内存结构和垃圾回收机制是每个Java工程师的必修课。
本文系统介绍JVM内存模型的核心概念、内存区域划分、垃圾回收算法及调优实战，帮助你构建扎实的JVM知识体系。

一、JVM整体架构

┌─────────────────────────────────────────────────────────────┐
│                        Java程序                             │
│                    (Source Code .java)                      │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│                    Java编译器 (javac)                        │
│                  编译为字节码 (.class)                       │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│                         JVM                                  │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │  类加载子系统  │  │  执行引擎    │  │    运行时数据区      │  │
│  │ Class Loader │  │ Interpreter │  │   Runtime Data Area │  │
│  │              │  │ JIT Compiler│  │                     │  │
│  │              │  │ GC          │  │                     │  │
│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

郑天祺2026/8/19大约 6 分钟

Java并发包核心：AQS原理深度剖析

AQS(AbstractQueuedSynchronizer)是Java并发包的基石，ReentrantLock、Semaphore、CountDownLatch等都基于它实现。
本文深入剖析AQS的设计思想、实现原理和源码分析，帮助你理解Java并发编程的核心机制。

一、AQS概述

1.1 AQS在并发包中的地位

java.util.concurrent包结构：

├── locks
│   ├── ReentrantLock        (基于AQS)
│   ├── ReentrantReadWriteLock (基于AQS)
│   └── StampedLock          (基于AQS)
├── synchronizers
│   ├── CountDownLatch       (基于AQS)
│   ├── CyclicBarrier        (基于Lock)
│   ├── Semaphore            (基于AQS)
│   └── Exchanger
└── atomic
    ├── AtomicInteger
    ├── AtomicLong
    └── AtomicReference

郑天祺2026/8/19大约 4 分钟

虚拟线程(Loom)：Java并发的未来

虚拟线程是Project Loom的核心成果，以极低的成本实现百万级并发，是Java并发编程的革命性突破。
本文系统介绍虚拟线程的设计理念、核心特性和实战应用，帮助你拥抱Java并发的未来。

一、线程模型演进

1.1 并发模型对比

模型	特点	优点	缺点
平台线程	1:1映射OS线程	稳定可靠	资源消耗大
协程	M:N映射	轻量级	需要特殊支持
虚拟线程	M:N映射	轻量级+平台线程API	新特性

郑天祺2026/8/19大约 5 分钟

Linux IO 模型深度解析：select、poll、epoll 与 Java NIO

Redis、Nginx、Netty 为什么快？因为它们底层都用 epoll。select、poll、epoll 到底什么区别？Java NIO 怎么映射到 Linux IO 模型？Reactor 模式怎么实现？一篇讲透。

一、五种 IO 模型

1.1 全景图

应用程序调用 recvfrom() 读数据的过程：

模型1：阻塞 IO（Blocking IO）
  用户线程：调用 recvfrom() → 阻塞 → 阻塞 → 阻塞 → 数据返回
  特点：整个等待 + 复制过程都阻塞

模型2：非阻塞 IO（Non-blocking IO）
  用户线程：调用 recvfrom() → 立即返回 EWOULDBLOCK
           再次调用 → EWOULDBLOCK → ... → 数据就绪 → 复制 → 返回
  特点：等待不阻塞但需要轮询（CPU 浪费）

模型3：IO 多路复用（IO Multiplexing）
  用户线程：调用 select/poll/epoll → 阻塞等待（可同时监控多个 FD）
           数据就绪 → 返回 → 调用 recvfrom() 复制数据
  特点：一个线程监控多个连接

模型4：信号驱动 IO（Signal-driven IO）
  用户线程：注册 SIGIO 信号 → 做其他事 → 数据就绪 → 收到信号
           → 调用 recvfrom() 复制数据
  特点：等待不阻塞，复制时阻塞

模型5：异步 IO（Asynchronous IO）
  用户线程：调用 aio_read() → 立即返回 → 做其他事
           → 数据复制完成 → 回调通知
  特点：全过程不阻塞（等待 + 复制都不阻塞）
  Linux: io_uring（5.1+）/ AIO
  Windows: IOCP

┌─────────────────────────────────────────────────────┐
│                                                     │
│   阻塞      等待数据        复制数据                  │
│   IO        ████████        ████                    │
│                                                     │
│   非阻塞    轮询（不阻塞）    ████                    │
│   IO        poll poll poll   ████                   │
│                                                     │
│   IO多路复用 select阻塞      ████                    │
│   (epoll)    （可监控多FD）   ████                   │
│                                                     │
│   信号驱动   信号通知          ████                   │
│   IO        （不阻塞）        ████                   │
│                                                     │
│   异步IO     不阻塞            不阻塞                  │
│   (AIO)     （回调通知）      （内核完成）              │
│                                                     │
└─────────────────────────────────────────────────────┘

郑天祺2026/7/3大约 8 分钟

AQS 源码深度剖析：ReentrantLock 与 Condition 的实现原理

AQS（AbstractQueuedSynchronizer）是 Java 并发包的基石。理解 AQS，就等于拿到了理解 ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock 等一系列同步工具的万能钥匙。本文将从核心设计到源码逐行剖析，带你彻底搞懂 AQS。

一、AQS 核心设计：state + CLH 队列

1.1 设计哲学

AQS 的核心思想可以用一句话概括：用一个 volatile int state 表示同步状态，用一个 CLH 变种队列管理等待线程。

郑天祺2026/7/3大约 16 分钟

CompletableFuture 异步编程：从串行到编排的完整指南

CompletableFuture 是 Java 8 引入的异步编程利器，它将 Future 的能力从"等待结果"扩展到"编排任务"。本文将从基础创建到复杂编排，全面剖析 CompletableFuture 的使用方法、底层原理和避坑技巧。

一、从 Future 到 CompletableFuture

1.1 Future 的局限性

// Future 的基本用法
ExecutorService executor = Executors.newFixedThreadPool(4);
Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "Hello";
});

// ❌ Future的三大局限：
// 1. 阻塞获取结果：get()会阻塞当前线程
String result = future.get();  // 阻塞！

// 2. 无法注册回调：不知道什么时候完成
// 只能轮询 isDone()
while (!future.isDone()) {
    // 忙等待，浪费CPU
}

// 3. 无法链式组合：A完成后触发B，再触发C...
// 需要嵌套调用，造成"回调地狱"

郑天祺2026/7/3大约 13 分钟

ConcurrentHashMap 源码解析：JDK 8 的并发安全策略

ConcurrentHashMap 是 Java 并发编程中使用频率最高的并发容器之一。从 JDK 7 的分段锁到 JDK 8 的 CAS + synchronized，其实现经历了重大演进。本文将深入剖析 JDK 8 中 ConcurrentHashMap 的核心实现，包括 put、get、扩容、size 等关键流程的源码级分析。

一、JDK 7 vs JDK 8 架构对比

1.1 JDK 7：分段锁（Segment）

┌─────────────────────────────────────────────────────────┐
│              JDK 7 ConcurrentHashMap 架构                │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌──────────┐  ┌──────────┐       ┌──────────┐         │
│  │ Segment0 │  │ Segment1 │  ...  │ Segment15│         │
│  │ (锁)     │  │ (锁)     │       │ (锁)     │         │
│  └────┬─────┘  └────┬─────┘       └────┬─────┘         │
│       │              │                  │               │
│       ▼              ▼                  ▼               │
│  ┌─────────┐    ┌─────────┐       ┌─────────┐          │
│  │Entry[]  │    │Entry[]  │       │Entry[]  │          │
│  │ table   │    │ table   │       │ table   │          │
│  └─────────┘    └─────────┘       └─────────┘          │
│                                                         │
│  默认16个Segment，每个Segment独立加锁                      │
│  并发度 = Segment数量（默认16）                           │
│  锁粒度：Segment级别                                     │
│                                                         │
└─────────────────────────────────────────────────────────┘

郑天祺2026/7/3大约 16 分钟