Java 高并发源码|深入解析高并发编程核心原理与实战

系统性讲解 JDK 并发包底层实现机制,结合生产级高并发系统架构设计,覆盖线程池、锁机制、并发容器、AQS 框架、CompletableFuture、ForkJoin 等核心模块,辅以真实项目案例解析,助你构建高吞吐、低延迟、高可用的 Java 高并发系统。

高并发编程核心认知框架

在分布式系统成为主流架构的今天,单机高并发处理能力仍是系统性能优化的基石。Java 作为企业级后端开发的主流语言,其并发工具包(java.util.concurrent)提供了完整、健壮的并发原语支持。理解这些组件的源码实现原理,不仅有助于写出高效、安全的并发代码,更是诊断线上高并发系统性能瓶颈、死锁、活锁等疑难问题的关键能力。

从 JVM 层面看,Java 线程模型基于操作系统原生线程(1:1 映射),其调度由操作系统内核负责。但 Java 并发包通过巧妙的设计,将线程生命周期管理、同步语义、上下文切换开销等细节进行了高度封装,开发者无需直接操作底层线程,却能构建出百万级 QPS 的高性能服务。

高并发系统设计需遵循三大黄金原则:① 最小化共享状态;② 最小化同步粒度;③ 最小化上下文切换。任何违背这三条原则的并发设计,都可能成为系统性能瓶颈或故障源头。例如,过度使用 synchronized 关键字会导致锁竞争激烈、线程频繁阻塞唤醒;而过细粒度的锁又可能引发死锁风险或增加内存开销。

深入源码是掌握高并发编程的必经之路。以 java.util.concurrent 包为例,其核心类如 ConcurrentHashMap、ThreadPoolExecutor、ReentrantLock、CountDownLatch 等均经过 JDK 团队多年优化,融合了无锁算法(如 CAS)、分段锁(Segment)、读写分离(StampedLock)、FIFO 队列(CLH 队列)等前沿并发技术。理解这些实现,是实现“知其然更知其所以然”的关键。

并发 vs 并行

并发(Concurrency)强调任务交替执行的能力,是逻辑上的同时发生;并行(Parallelism)强调任务真正同时执行,是物理上的同时发生。单核 CPU 下只能实现并发,多核 CPU 下才能实现并行。高并发系统设计必须考虑 CPU 核心数、任务类型(CPU 密集型 vs IO 密集型)对资源调度的影响。

上下文切换开销

线程切换需保存当前寄存器、程序计数器、栈状态等,再加载新线程上下文,单次开销约 1~10 微秒。当线程数远超 CPU 核心数时,频繁切换会显著降低有效计算时间。优化策略包括:使用线程池复用线程、减少锁持有时间、采用无锁算法、使用协程(Virtual Thread)等。

内存可见性问题

由于 CPU 多级缓存存在,一个线程对共享变量的修改,可能不会立即写入主内存,导致其他线程读取到过期值。Java 内存模型(JMM)通过 volatile、synchronized、final 关键字及 happens-before 规则保障内存可见性。例如 volatile 变量写入会强制刷新到主存,读取时从主存加载,确保可见性。

高并发系统典型瓶颈分析

生产环境高并发问题往往表现为:请求延迟飙升、线程池拒绝策略频繁触发、CPU 使用率异常偏高、GC 次数激增、死锁导致服务不可用等。根本原因通常可归结为以下几类:

  • 锁竞争激烈:多个线程竞争同一把锁(如全局 synchronized),导致大量线程阻塞等待,吞吐量骤降。
  • 线程过多:无限制创建线程(如每次请求新建 Thread),消耗大量内存(每线程默认栈空间 1MB),增加调度开销。
  • 无锁但 CAS 失败率高:使用 AtomicInteger 等 CAS 原子类时,若写入冲突频繁(如高并发计数器),自旋重试导致 CPU 空转。
  • 内存屏障缺失:未使用 volatile 或 synchronized,导致线程间数据不一致,引发逻辑错误(如 double-check locking 单例失效)。

线程池源码深度解析

ThreadPoolExecutor 是 Java 并发包中最重要的线程管理组件,其设计融合了工作窃取、线程复用、动态扩容、拒绝策略等先进思想。理解其源码实现,是构建高吞吐、低延迟服务的关键前提。

ThreadPoolExecutor 的核心参数包括:corePoolSize(核心线程数)、maximumPoolSize(最大线程数)、keepAliveTime(空闲线程存活时间)、workQueue(工作队列)、rejectedExecutionHandler(拒绝策略)。其内部维护了一个原子变量 ctl,高 3 位表示线程池状态(RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED),低 29 位表示工作线程数,通过位运算高效合并状态与线程数。

提交任务时,线程池按以下逻辑处理:

  1. 若当前线程数 < corePoolSize,直接创建新线程执行任务(即使有空闲线程);
  2. 若线程数 ≥ corePoolSize,尝试将任务加入 workQueue;
  3. 若队列已满,且线程数 < maximumPoolSize,创建新线程处理任务;
  4. 若线程数已达上限,执行拒绝策略。

这一流程可通过一张状态转换图清晰表达:当线程池处于 RUNNING 状态时,任务提交成功;调用 shutdown() 后进入 SHUTDOWN 状态,不再接收新任务,但继续处理队列中任务;调用 shutdownNow() 后进入 STOP 状态,中断所有线程并清空队列。

execute() 核心源码逻辑

public void execute(Runnable command) {
  if (command == null)
      throw new NullPointerException();
  int c = ctl.get();
  // 1. 当前线程数 < corePoolSize,创建新线程
  if (workerCountOf(c) < corePoolSize) {
      if (addWorker(command, true))
          return;
      c = ctl.get();
  }
  // 2. 尝试入队(仅 RUNNING 状态允许)
  if (isRunning(c) && workQueue.offer(command)) {
      int recheck = ctl.get();
      // 双重检查:若已非 RUNNING,移除任务并拒绝
      if (!isRunning(recheck) && remove(command))
          reject(command);
      else if (workerCountOf(recheck) == 0)
          addWorker(null, false); // 确保有线程处理队列
  }
  // 3. 入队失败,尝试创建非核心线程
  else if (!addWorker(command, false))
      // 4. 创建失败,执行拒绝策略
      reject(command);
}

关键点解析:addWorker() 方法负责创建并启动工作线程(Worker),其内部通过 CAS 更新 ctl,并将任务封装为 Worker 对象加入 workers 集合。Worker 实现了 Runnable 接口,其 run() 方法最终调用 runWorker(),循环从 workQueue 取任务执行,实现线程复用。当线程空闲时间超过 keepAliveTime 时,非核心线程会被终止,体现动态扩容缩容能力。

workQueue 类型对比

队列类型 适用场景 优缺点
ArrayBlockingQueue bounded queues,需预估容量,如订单处理 优点:有界队列,内存可控;缺点:固定容量,扩展性差
LinkedBlockingQueue 默认无界,适合任务量波动大场景 优点:高吞吐;缺点:内存溢出风险(OOM)
SynchronousQueue 直接提交,无缓冲,如 ForkJoinPool 优点:低延迟;缺点:需配合足够线程数,否则频繁拒绝
PriorityBlockingQueue 优先级任务,如告警通知 优点:支持优先级调度;缺点:入队需比较,开销略高

生产建议:核心线程数 ≈ CPU 核心数(CPU 密集型)或 2×(IO 密集型);最大线程数 = 核心数 + (最大并发请求数 - 队列容量) / 每线程处理时长;队列容量需结合 JVM 堆内存与预期峰值计算,避免 OOM。

拒绝策略详解

当线程池达到 maximumPoolSize 且队列满时,新任务将触发拒绝策略。JDK 提供四种内置策略:

  • AbortPolicy:默认策略,抛出 RejectedExecutionException 异常,需业务层捕获处理。
  • CallerRunsPolicy:由调用线程(提交任务的线程)执行任务,可减缓提交速率,适用于临时降级场景。
  • DiscardPolicy:直接丢弃任务,不抛异常,适用于非关键任务(如日志上报)。
  • DiscardOldestPolicy:丢弃队首任务,尝试提交新任务,适用于实时性要求高的场景。

实际应用中,常自定义拒绝策略实现降级逻辑,例如:记录告警日志 + 将任务持久化到 DB/Redis + 后续补偿任务。示例代码:

ExecutorService executor = new ThreadPoolExecutor(
    10, 20, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),
    r -> {
      Thread t = new Thread(r);
      t.setName("biz-worker-" + t.getId());
      return t;
    },
    (r, e) -> {
      // 自定义降级:记录日志并持久化
      log.warn("任务被拒绝: {}", r);
      persistentQueue.offer(r); // 持久化到 Redis List
    }
);

线程池最佳实践

① 避免使用 Executors 工具类创建线程池(如 newFixedThreadPool),因其默认使用无界队列,易导致 OOM;② 为每个业务模块独立配置线程池,防止相互影响;③ 设置有意义的线程名(如 "order-pay-worker-1"),便于问题定位;④ 监控线程池指标(活跃线程数、队列长度、拒绝次数),接入 APM(如 SkyWalking);⑤ 对关键任务设置超时机制,避免长时间阻塞。

锁机制:从 synchronized 到StampedLock

Java 锁机制经历了从重量级(synchronized)到轻量级(CAS)的演进。synchronized 是 JVM 内置锁,通过对象头 Mark Word 实现锁升级(无锁 → 偏向锁 → 轻量级锁 → 重量级锁),在无竞争时开销极低,但高竞争下性能较差。而 Lock 接口的实现(如 ReentrantLock)基于 AQS 框架,提供更灵活的锁语义(可中断、超时、公平性),是构建高性能并发系统的首选。

ReentrantLock 的核心是 Sync 类(继承 AQS),其公平锁与非公平锁的区别在于:非公平锁在 acquire() 时直接尝试 CAS 获取,若失败再入队;公平锁则直接入队,确保 FIFO 顺序。非公平锁虽可能造成线程饥饿,但减少了线程挂起唤醒开销,整体吞吐量更高。

ReentrantLock 源码关键点

tryAcquire() 方法是锁获取的核心逻辑,以非公平锁为例:

final boolean nonfairTryAcquire(int acquires) {
  final Thread current = Thread.currentThread();
  int c = getState();
  // 1. 无锁状态,尝试 CAS 获取
  if (c == 0) {
      if (compareAndSetState(0, acquires)) {
          setExclusiveOwnerThread(current);
          return true;
      }
  }
  // 2. 已持有锁,检查是否为当前线程(重入)
  else if (current == getExclusiveOwnerThread()) {
      int nextc = c + acquires;
      if (nextc < 0) // 溢出检查
          throw new Error("Maximum lock count exceeded");
      setState(nextc);
      return true;
  }
  return false;
}

释放锁时,tryRelease() 递减 state,为 0 时唤醒等待线程。ReentrantLock 支持条件变量(Condition),可实现类似 Object.wait/notify 的线程协作,但更安全(避免 IllegalMonitorStateException)。典型应用:生产者-消费者模型中,使用两个 Condition 分别控制“队列非满”和“队列非空”。

读写锁(ReadWriteLock)

读写锁将锁分为读锁(共享)和写锁(排他),允许多个读线程并发访问,但写线程独占。适用于“读多写少”场景(如缓存更新、配置管理)。其核心实现是 ReadWriteLock 接口的子类 ReentrantReadWriteLock,内部维护两个锁:ReadLock 和 WriteLock。

典型场景:缓存失效时,多个线程同时读取缓存未命中,可能并发访问数据库,导致“缓存击穿”。使用 ReadWriteLock 可优化:读线程加读锁,写线程加写锁;当缓存失效时,仅一个线程获取写锁更新缓存,其余线程等待后直接读取新缓存。

// 缓存示例
class Cache {
  private final Map map = new HashMap<>();
  private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
  public Object get(String key) {
    rwLock.readLock().lock();
    try {
      return map.get(key);
    } finally {
      rwLock.readLock().unlock();
    }
  }
  public void put(String key, Object value) {
    rwLock.writeLock().lock();
    try {
      map.put(key, value);
    } finally {
      rwLock.writeLock().unlock();
    }
  }
}

StampedLock 深度对比

StampedLock 是 Java 8 引入的乐观读写锁,支持三种模式:写锁(排他)、悲观读锁(共享)、乐观读锁(不阻塞写)。其核心是 stamp(时间戳),每次锁操作返回唯一 stamp,用于验证锁状态是否失效。

乐观读锁是StampedLock的亮点:读线程不阻塞写线程,仅通过 stamp 校验读取期间是否发生写入。若校验失败(stamp 变化),则降级为悲观读锁重试。适用于读性能要求极高、写冲突较少的场景(如金融行情数据读取)。

使用示例:

class Point {
  private double x, y;
  private final StampedLock sl = new StampedLock();
  double distanceFromOrigin() {
    // 1. 乐观读
    long stamp = sl.tryOptimisticRead();
    double currentX = x, currentY = y;
    // 2. 校验 stamp 是否失效(写操作是否发生)
    if (!sl.validate(stamp)) {
      // 3. 失效则升级为悲观读锁
      stamp = sl.readLock();
      try {
        currentX = x;
        currentY = y;
      } finally {
        sl.unlockRead(stamp);
      }
    }
    return Math.sqrt(currentX * currentX + currentY * currentY);
  }
  void move(double deltaX, double deltaY) {
    long stamp = sl.writeLock();
    try {
      x += deltaX;
      y += deltaY;
    } finally {
      sl.unlockWrite(stamp);
    }
  }
}

注意:StampedLock 不支持条件变量,且锁不可重入,需谨慎使用。

锁的常见陷阱与规避

  • 死锁:多线程互相等待对方释放锁。规避:统一加锁顺序、使用 tryLock() 超时、避免嵌套锁。
  • 活锁:线程不断重试但始终失败(如冲突时回退重试)。规避:引入随机退避时间、使用公平锁。
  • 饥饿:某些线程长期无法获取锁。规避:使用公平锁、限制线程优先级差异。
  • 锁粗化:将多个连续锁合并为一个大锁,降低并发性。规避:缩小锁粒度,仅包裹临界区。

并发容器:从 ConcurrentHashMap 到 ConcurrentSkipListMap

Java 并发容器通过分段锁、CAS、volatile 等技术,在保证线程安全的同时提升并发性能。ConcurrentHashMap 是最常用的并发 Map,其 JDK 8 版本彻底摒弃分段锁,采用 CAS + synchronized 实现更细粒度的锁控制,性能大幅提升。

ConcurrentHashMap 的核心结构是 Node 数组(链表/红黑树),put 操作流程:① 计算 key 的 hash;② 定位数组索引;③ 若该位置为空,CAS 插入新节点;④ 若不为空,synchronized 该链表头节点,遍历插入或更新;⑤ 链表长度 ≥ 8 且数组长度 ≥ 64 时,转为红黑树。

ConcurrentHashMap 核心原理

其关键优化点在于:① 使用 volatile 保证 table 数组的可见性;② 链表头节点加锁,避免全局锁;③ 红黑树旋转时保持平衡,避免退化;④ 扩容时支持多线程协作(每个线程负责部分桶迁移)。

扩容过程:当 sizeCtl 为负数时,表示正在扩容,其低 16 位表示参与线程数。每个线程通过 CAS 更新 sizeCtl,获取一个桶区间(如 [i, i+stride)),迁移该区间内所有节点。迁移完成后,检查是否所有桶已迁移,若是则完成扩容。

典型性能数据:在 8 核 CPU、100 万次 put 操作下,ConcurrentHashMap 吞吐量约为 HashMap(无锁)的 70%,而 synchronized HashMap 仅约 15%。

CopyOnWriteArrayList 深度解析

适用于读多写少场景(如事件监听器列表)。其核心是“写时复制”:写操作时,先复制原数组,再修改副本,最后用 volatile 写入新数组。读操作无需加锁,直接读取原数组,保证强一致性。

源码关键点:

public E set(int index, E element) {
  final ReentrantLock lock = this.lock;
  lock.lock();
  try {
    Object[] elements = getArray();
    E oldValue = elementAt(elements, index);
    if (oldValue != element) {
      int len = elements.length;
      Object[] newElements = Arrays.copyOf(elements, len);
      newElements[index] = element;
      setArray(newElements); // volatile 写
    } else {
      setArray(elements);
    }
    return oldValue;
  } finally {
    lock.unlock();
  }
}

缺点:写操作开销大(数组复制),内存占用高(双份数组)。不适合写频繁场景,否则导致频繁 GC。

跳表(SkipList)在并发中的应用

ConcurrentSkipListMap 和 ConcurrentSkipListSet 基于跳表实现,支持高并发的有序 Map/Set。跳表通过多级索引实现 O(log n) 查找、插入、删除,性能接近平衡树,但实现更简单、支持并发操作。

其节点结构包含:key、value、next 数组(每级索引指针)、level(当前节点最高级数)。插入时随机生成 level(通常概率 0.5),动态维护索引。

并发控制:使用 CAS 更新 next 指针,确保多线程插入时索引一致性。读操作无需锁,写操作局部加锁(仅涉及节点),适合高并发有序数据场景(如排行榜、时间序列数据)。

并发容器选型指南

Map 场景

• 高并发读写 → ConcurrentHashMap
• 有序 Map → ConcurrentSkipListMap
• 单线程 → HashMap

List 场景

• 读多写少 → CopyOnWriteArrayList
• 高频写入 → Collections.synchronizedList(new ArrayList<>())
• 单线程 → ArrayList

Set 场景

• 高并发 → ConcurrentHashMap.newKeySet()
• 有序 → ConcurrentSkipListSet
• 单线程 → HashSet

AQS 框架:并发工具的基石

AbstractQueuedSynchronizer(AQS)是 ReentrantLock、Semaphore、CountDownLatch 等并发工具的核心骨架。它通过一个 volatile int state(共享状态)和 CLH 队列(双向同步队列)实现锁语义,将同步器的实现简化为对 state 的 CAS 操作与队列管理。

CLH 队列是 AQS 的核心数据结构:每个节点(Node)包含前驱/后继指针、线程引用、等待状态(SHARED/EXCLUSIVE)、取消状态等。当线程获取同步状态失败时,被封装为 Node 加入队尾;成功获取后,队首节点出队并唤醒后继线程。

AQS 核心方法

开发者需重写以下方法实现自定义同步器:

  • tryAcquire(int):独占式获取同步状态
  • tryRelease(int):独占式释放同步状态
  • tryAcquireShared(int):共享式获取同步状态(返回值 ≥0 表示成功)
  • tryReleaseShared(int):共享式释放同步状态
  • isHeldExclusively():当前线程是否独占持有同步状态

AQS 提供模板方法:acquire()/release()(独占)、acquireShared()/releaseShared()(共享),内部调用上述重写方法与队列操作,实现统一调度逻辑。

CountDownLatch 源码分析

基于 AQS 的共享模式实现。state 初始化为计数值(count),await() 调用 acquireShared(1),doAcquireShared() 循环检查 state 是否为 0;countDown() 调用 releaseShared(1),doReleaseShared() 中 state 减 1,若为 0 则唤醒所有等待线程。

典型应用:主线程等待多个子线程初始化完成后再启动。

// 主线程等待 3 个子线程
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
  new Thread(() -> {
    // 初始化逻辑
    latch.countDown();
  }).start();
}
latch.await(); // 阻塞直到 count=0
System.out.println("所有子线程初始化完成");

Semaphore 实现原理

用于控制并发线程数(如数据库连接池)。state 表示可用许可数,acquire() 尝试 CAS 减 state,失败则入队等待;release() CAS 加 state,唤醒后继节点。

公平性:公平 Semaphore 优先唤醒队首线程;非公平则直接尝试获取,可能插队。

手写自定义同步器示例

实现一个“单次执行器”(SingleRunLatch),确保任务仅执行一次:

class SingleRunLatch {
  private final Sync sync = new Sync();
  private static class Sync extends AbstractQueuedSynchronizer {
    @Override protected boolean tryAcquire(int acquires) {
      return compareAndSetState(0, 1);
    }
    @Override protected boolean tryRelease(int releases) {
      throw new UnsupportedOperationException();
    }
    @Override protected void lock() {
      acquire(1);
    }
    @Override protected void unlock() {
      throw new UnsupportedOperationException();
    }
  }
  public void runOnce(Runnable task) {
    sync.lock();
    try {
      task.run();
    } finally {
      sync.unlock(); // 实际不会释放,但保留结构完整性
    }
  }
}

异步编程模型:CompletableFuture 深度实战

CompletableFuture 是 Java 8 引入的异步编程工具,支持函数式编程风格(map/flatMap)、组合操作(thenCombine)、异常处理(exceptionally),极大简化了异步任务编排。其底层基于 ForkJoinPool 实现,可高效利用多核资源。

核心特性:① 非阻塞式结果获取(get() 阻塞,join() 非检查异常);② 链式调用与组合;③ 回调式执行(whenComplete、thenApply);④ 支持超时与取消。

CompletableFuture 基础用法

创建方式:① runAsync()(无返回值);② supplyAsync()(有返回值);③ 自定义 Executor。

// 异步获取用户信息 + 订单信息,合并后返回
CompletableFuture.supplyAsync(() -> getUser(id))
  .thenCombine(CompletableFuture.supplyAsync(() -> getOrder(id)),
    (user, order) -> new OrderDetail(user, order))
  .exceptionally(ex -> {
    log.error("处理失败", ex);
    return null;
  })
  .thenAccept(detail -> System.out.println(detail));

注意:默认使用 ForkJoinPool.commonPool(),若任务阻塞(如 IO),可能耗尽线程池。建议指定专用线程池:

ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture.supplyAsync(() -> {
  // 模拟耗时操作
  Thread.sleep(500);
  return "result";
}, executor);

异步编排最佳实践

① 避免嵌套过深:使用 thenCompose 替代 thenApply + CompletableFuture;

// 不推荐:嵌套
thenApply(user ->
  CompletableFuture.supplyAsync(() -> getOrder(user.getId()))
)
// 推荐:扁平化
thenCompose(user ->
  CompletableFuture.supplyAsync(() -> getOrder(user.getId()))
)

② 统一异常处理:在链末尾添加 exceptionally 或 handle;

③ 超时控制:结合 ScheduledExecutorService 实现 timeoutFuture;

CompletableFuture timeout = new CompletableFuture<>();
ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
scheduler.schedule(() -> timeout.completeExceptionally(new TimeoutException()), 1, TimeUnit.SECONDS);
CompletableFuture.anyOf(resultFuture, timeout)
  .thenAccept(System.out::println)
  .exceptionally(ex -> "超时");

与 reactive streams 对比

CompletableFuture 适合单次异步任务;而 reactive streams(如 Project Reactor、RxJava)适合流式数据处理(背压、多元素)。对于复杂业务编排(如订单创建需调用 10+ 个服务),推荐使用 reactive streams;对于简单异步任务,CompletableFuture 更轻量。

CompletableFuture 典型陷阱

  • 默认线程池耗尽:异步任务阻塞 commonPool,导致其他任务无法执行。解决:显式指定线程池。
  • 未处理异常:未加 exceptionally,异常被静默丢弃。解决:每个链末尾添加异常处理。
  • 循环异步创建:for 循环中创建多个 CompletableFuture,未控制并发数。解决:使用 batch 分批处理或限流器。

Netty 高并发网络模型:从 Reactor 模式到零拷贝

Netty 是基于 Java NIO 的高性能网络框架,其核心是 Reactor 模式 + 事件驱动 + 零拷贝技术。典型架构包括:BossGroup(处理连接请求)、WorkerGroup(处理 IO 事件)、ChannelPipeline(处理业务逻辑)。

Reactor 模式将 IO 操作与业务逻辑解耦:① Reactor 线程监听事件(accept/read/write);② 事件分发给 Handler;③ Handler 执行非阻塞业务逻辑;④ 结果通过 writeAndFlush 返回。Netty 默认采用主从 Reactor 模式(多线程),BossGroup 仅处理连接,WorkerGroup 处理 IO,充分利用多核。

Netty 核心组件

  • EventLoopGroup:线程池,每个线程管理多个 Channel 的 IO 事件。
  • Channel:网络连接抽象,支持读写、连接、绑定等操作。
  • Pipeline:Handler 链,每个 Handler 处理特定逻辑(入站/出站)。
  • ByteBuf:高性能内存管理,支持直接内存、池化、引用计数。

典型服务端启动代码:

ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
  .channel(NioServerSocketChannel.class)
  .childHandler(new ChannelInitializer() {
    @Override
    public void initChannel(SocketChannel ch) {
      ch.pipeline().addLast(new ServerHandler());
    }
  });
b.bind(8080).sync();

零拷贝技术详解

Netty 实现零拷贝的三种方式:① CompositeByteBuf:逻辑合并多个 ByteBuf,避免物理拷贝;② FileRegion:基于 Linux sendfile() 直接传输文件,用户态不参与数据拷贝;③ DirectMemory:堆外内存,避免 JVM 堆到 OS 堆的拷贝。

sendfile() 系统调用流程:应用 → 内核缓冲区(DMA 拷贝)→ 网卡(DMA 拷贝),全程无需 CPU 参与数据搬运,显著降低 CPU 使用率。

高并发优化实践

  • 线程模型:BossGroup 线程数 = CPU 核心数;WorkerGroup 线程数 = CPU 核心数 × 2。
  • 内存管理:使用 PooledByteBufAllocator,减少 GC 压力。
  • 编解码:使用 LineBasedFrameDecoder + StringDecoder 避免拆包粘包。
  • 心跳检测:IdleStateHandler 检测空闲连接,及时释放资源。

Netty 典型故障排查

① 内存泄漏:ByteBuf 未 release,通过 -Dio.netty.leakDetectionLevel=ADVANCED 开启检测;

② 线程阻塞:Handler 中执行耗时操作(如 DB 查询),导致 IO 线程阻塞。解决:异步提交到业务线程池;

③ 粘包/拆包:未正确配置解码器,导致数据错乱。解决:使用 FixedLengthFrameDecoder 或自定义解码器。

网友最关心的 10 个高并发问题

Q1:为什么我的线程池拒绝策略没生效?

A:可能原因:① workQueue 为无界队列(如 LinkedBlockingQueue 默认容量 Integer.MAX_VALUE),任务不会入队满,故不会触发拒绝;② maximumPoolSize 设置过小,但线程创建未达上限。检查:确保 workQueue 有界,且 maximumPoolSize > corePoolSize。

Q2:ConcurrentHashMap 的 size() 方法为什么不准?

A:JDK 8 中 size() 通过 CAS 累加 baseCount + CounterCell 数组,为近似值。精确值需调用 mappingCount()(返回 long),但性能较低。若需强一致性,应加外部锁或使用 Collections.synchronizedMap。

Q3:CompletableFuture 的异常如何传递?

A:默认异常会中断链式调用。使用 exceptionally 处理异常后继续执行;或用 handle 统一处理(无论成功/失败)。示例:handle((r, ex) -> ex != null ? defaultValue : r)。

Q4:ReentrantLock 和 synchronized 性能对比?

A:JDK 6 后 synchronized 经过大量优化(自适应自旋、锁粗化等),在无竞争场景下性能接近 ReentrantLock;高竞争下 ReentrantLock 更优(支持公平锁、超时、中断)。生产建议:优先用 synchronized,复杂场景用 ReentrantLock。

Q5:如何避免 CopyOnWriteArrayList 的 OOM?

A:严格限制集合大小(如 1024 元素),写操作前检查大小;或改用 ReadWriteLock + ArrayList。适用于监听器列表(元素固定少)等场景,避免用于缓存列表。

Q6:AQS 的 state 为什么用 volatile 修饰?

A:保证多线程间 state 的可见性。CAS 操作依赖 volatile 语义,确保读取到最新值。若无 volatile,线程可能读取到过期 state 值,导致 CAS 失败或逻辑错误。

Q7:Netty 的 EventLoop 线程为什么不能阻塞?

A:EventLoop 线程负责处理 IO 事件和任务队列。若阻塞(如 sleep、DB 查询),该线程无法处理其他 Channel 的 IO,导致连接堆积、请求超时。正确做法:耗时任务提交到业务线程池。

Q8:如何监控线程池健康状态?

A:扩展 ThreadPoolExecutor,重写 beforeExecute/afterExecute 方法记录日志;或定时获取 poolSize、activeCount、queue.size() 等指标,接入 Prometheus + Grafana 监控。

Q9:CompletableFuture 和线程池的关系?

A:supplyAsync() 默认使用 ForkJoinPool.commonPool(),若需控制并发度,必须指定 Executor。常见错误:在 high-concurrency 场景下使用默认线程池,导致任务排队延迟。

Q10:高并发系统如何设计限流?

A:常用方案:① 令牌桶(Guava RateLimiter);② 漏桶(Netty 的 ChannelTrafficShapingHandler);③ 计数器(AtomicInteger + 定时窗口)。建议:入口层用令牌桶,业务层用漏桶,保护下游服务。

延伸阅读与学习路径

掌握高并发编程需系统性学习,建议按以下路径进阶:

第 1 阶段(1~2 月)

基础夯实

精读《Java 并发编程实战》(Brian Goetz),掌握线程安全、锁、volatile、JMM 基础概念,动手实现简易线程池。

第 2 阶段(2~3 月)

源码突破

逐行分析 JDK 源码:ThreadPoolExecutor、ConcurrentHashMap、AQS,结合调试工具(IntelliJ)跟踪执行流程,绘制状态转换图。

第 3 阶段(3~6 月)

实战应用

重构个人项目:用 Netty 实现 HTTP 服务器;用 CompletableFuture 编排异步任务;用 Redis + 分布式锁实现库存扣减。

第 4 阶段(6 月+)

架构升级

研究大型系统高并发设计:秒杀系统(令牌桶 + 本地缓存)、日志系统(异步刷盘 + 批量写入)、消息队列(零拷贝 + 磁盘顺序写)。