java并发编程入门

在当今高并发互联网系统中,java并发编程已成为后端工程师必须掌握的核心能力之一。从秒杀系统到实时数据处理,从分布式服务通信到高吞吐消息队列,底层都依赖于对线程调度、资源竞争、内存模型等并发机制的精准控制。

本指南面向具备基础Java语法知识的开发者,系统梳理并发编程的关键知识点,结合真实工程实践,帮助您构建完整的并发知识体系。内容覆盖从线程创建与生命周期、同步机制原理、JMM内存模型、并发工具类使用,到线程池设计、锁优化策略、性能调优等进阶主题,每一环节均配有可运行的代码示例与常见误区解析。

学习本课程后,您将能够:

并发编程不是“锦上添花”的技能,而是构建高可用、高并发系统的基石。据2025年Stack Overflow开发者调查,超过78%的Java后端开发者将并发问题列为最困扰他们的技术难点之一。而系统性学习本指南内容,可显著降低此类问题的发生率。

一、并发基础:线程本质与创建方式

在深入同步机制前,必须厘清线程的底层行为。线程是CPU执行调度的基本单位,其本质是“共享进程资源的独立执行流”。在JVM中,每个线程拥有独立的栈空间(存储局部变量、操作数栈、帧数据),但共享堆内存与方法区。这种资源隔离与共享的混合模式,正是并发Bug频发的根本原因。

1.1 线程的五种状态

Java线程状态由Thread.State枚举定义,对应JVM规范中的五种状态:

  1. NEW:线程对象已创建但未调用start(),如Thread t = new Thread();
  2. RUNNABLE:包含就绪(Ready)与运行(Running),线程已启动且正在等待或占用CPU;
  3. BLOCKED:线程因竞争synchronized监视器锁而阻塞;
  4. WAITING/TIMED_WAITING:因调用wait()、join()、LockSupport.park()等进入等待状态;
  5. TERMINATED:run()方法执行完毕或未捕获异常退出。

常见误区:线程状态为RUNNABLE时,不代表一定在执行代码——它可能正等待I/O或等待其他资源。可通过jstack工具查看线程实际阻塞点。

1.2 线程创建的三种方式

⚡ 继承Thread类

class MyThread extends Thread {
    public void run() {
        System.out.println("线程执行中...");
    }
}
new MyThread().start();

⚙️ 实现Runnable接口

class MyTask implements Runnable {
    public void run() {
        System.out.println("任务执行中...");
    }
}
new Thread(new MyTask()).start();

⚡ Lambda表达式

new Thread(() -> {
    System.out.println("Lambda任务执行...");
}).start();

推荐优先使用Runnable或Lambda方式,因其支持任务与线程分离,便于线程池复用。继承Thread会限制类的扩展性(Java单继承)。

1.3 线程中断机制详解

中断是协作式机制,非强制终止线程。核心方法:

正确处理中断的示例:

while (!Thread.currentThread().isInterrupted()) {
    try {
        // 执行业务逻辑
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // 恢复中断状态
        Thread.currentThread().interrupt();
        break;
    }
}

注意:调用sleep()、wait()等阻塞方法时,线程会立即响应中断并抛出InterruptedException,此时必须处理中断状态以避免丢失中断信号。

二、核心机制:内存模型与同步原语

2.1 JMM内存模型核心概念

Java内存模型(JMM)定义了线程如何访问共享变量。关键原则:

典型反例:双重检查锁定单例的错误写法(未加volatile)

class Singleton {
    private static Singleton instance; // 缺少volatile!
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null)
                    instance = new Singleton(); // 可能重排序导致未完全初始化
            }
        }
        return instance;
    }
}

修正方案:将instance声明为volatile

2.2 synchronized深度解析

synchronized通过对象监视器(Monitor)实现同步。其底层机制:

适用场景:

2.3 volatile的语义与限制

volatile仅保证可见性与有序性,不保证原子性。典型用例:

错误示例(非原子操作):

volatile int count = 0;
// 多线程执行:count++ 仍会导致计数丢失

正确替代方案:使用AtomicInteger

三、并发工具类:JUC核心组件实战

CountDownLatch
CyclicBarrier
Semaphore
ConcurrentHashMap

CountDownLatch:倒计时门栓

用于等待多个线程完成后再继续执行。典型场景:主线程等待所有子线程初始化完成。

CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        System.out.println("子线程执行...");
        latch.countDown();
    }).start();
}
latch.await(); // 阻塞直到计数为0
System.out.println("所有子线程完成!");

注意:计数器不可重置,一次性的。

CyclicBarrier:循环栅栏

所有线程到达屏障点后一起继续执行。支持重置,可设置barrierAction在屏障点执行。

CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有线程就位,开始计算!");
});
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        try {
            System.out.println("线程" + Thread.currentThread().getName() + "就位");
            barrier.await();
            System.out.println("线程继续执行");
        } catch (Exception e) { e.printStackTrace(); }
    }).start();
}

Semaphore:信号量

控制同时访问特定资源的线程数。常用于连接池、流量控制。

Semaphore sem = new Semaphore(2); // 仅允许2个线程同时访问
for (int i = 0; i < 5; i++) {
    new Thread(() -> {
        try {
            sem.acquire();
            System.out.println("获取许可,执行中...");
            Thread.sleep(1000);
        } catch (InterruptedException e) { e.printStackTrace(); }
        finally { sem.release(); }
    }).start();
}

ConcurrentHashMap:线程安全Map

JDK8采用CAS+synchronized优化,分段锁升级为桶级锁。关键特性:

  • put操作:首节点为null时用CAS,否则加synchronized;
  • 扩容:支持多线程并发扩容;
  • 遍历:弱一致性迭代器(不抛ConcurrentModificationException)。

注意:size()方法返回近似值(因并发修改),精确计数需用LongAdder。

2.4 线程池原理与参数设计

线程池通过复用线程减少创建开销。核心参数:

参数说明推荐值
corePoolSize核心线程数CPU核心数+1(CPU密集型)
或2×CPU核心数(IO密集型)
maximumPoolSize最大线程数根据队列容量与任务特性调整
keepAliveTime非核心线程存活时间60秒(默认)
workQueue任务队列LinkedBlockingQueue(无界)
或ArrayBlockingQueue(有界)

推荐使用Executors工具类的预设线程池,或自定义ThreadPoolExecutor避免OOM风险:

ExecutorService pool = new ThreadPoolExecutor(
    4, 8, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),
    new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

四、线程池进阶:设计原则与故障排查

4.1 线程池拒绝策略

当队列满且线程达最大值时触发拒绝策略:

生产环境推荐CallerRunsPolicy,可反压上游服务。

4.2 典型故障场景

排查工具:

五、并发优化:从理论到工程实践

5.1 锁优化策略

① 减少锁持有时间

仅同步必要代码块,避免同步整个方法

② 降低锁粒度

使用分段锁(如ConcurrentHashMap的segment)

③ 读写分离

用ReentrantReadWriteLock替代synchronized

④ 锁粗化

循环内多次加锁 → 合并到循环外

5.2 避免常见陷阱

解决方案:

六、实战案例:高并发场景解决方案

6.1 秒杀系统设计

核心挑战:库存超卖、请求积压、服务雪崩

6.2 日志异步写入

使用Disruptor或自定义线程池异步刷盘:

public class AsyncLogger {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();
    public void log(String msg) {
        executor.execute(() -> {
            // 磁盘I/O操作
            Files.write(Paths.get("app.log"),
                       (msg + "\n").getBytes(),
                       StandardOpenOption.APPEND);
        });
    }
}

注意:需处理队列满时的拒绝策略,避免OOM。

七、网友最关心的10个问题

  1. 线程安全是否意味着性能差?
    否。合理使用无锁技术(如Atomic类、ThreadLocal)可兼顾安全与性能。例如ConcurrentHashMap在高并发下性能远超Hashtable。
  2. volatile能替代synchronized吗?
    不能。volatile仅保证可见性,无法保证复合操作的原子性(如i++)。
  3. 如何检测线程死锁?
    使用jstack -l [pid]分析线程堆栈,或通过jconsole图形界面查看。
  4. 线程池大小如何设置?
    CPU密集型:核心数+1;IO密集型:2×核心数。实际需压测验证。
  5. CountDownLatch和CyclicBarrier有何区别?
    CountDownLatch是减计数(1个线程等待多个),CyclicBarrier是加计数(多个线程互相等待)。
  6. ConcurrentHashMap的size()为什么不准?
    为避免全表加锁,其返回近似值。需精确计数请用LongAdder。
  7. 如何优雅关闭线程池?
    先调shutdown()阻止新任务,再awaitTermination()等待已完成任务。
  8. 线程池中出现OOM怎么办?
    检查队列是否无界(如LinkedBlockingQueue默认容量Integer.MAX_VALUE),改用有界队列。
  9. Java中如何实现线程安全的单例?
    推荐:静态内部类或枚举;避免双重检查锁定(需volatile)。
  10. 高并发下如何避免日志阻塞?
    使用异步日志框架(如Logback AsyncAppender),设置队列上限并配置丢弃策略。

〔新手必读〕

并发编程需循序渐进:先理解线程基础 → 掌握同步原语 → 熟悉工具类 → 深入源码原理 → 实战调优。切忌跳过基础直接研究源码。

〔性能黄金法则〕

“并发不是越多线程越好!线程数 = CPU核心数 × (1 + 等待时间/计算时间)。过度并发反而降低吞吐量。

最后提醒:所有并发问题必须复现才能修复。建议在测试环境用JMH(Java Microbenchmark Harness)进行基准测试,避免生产环境“试错”。