java多线程编程学习

在当今分布式高并发系统架构中,Java多线程编程已成为构建高性能、高可用后端服务的基石能力。无论是电商秒杀系统、实时数据处理引擎,还是微服务网关与消息中间件,其底层无不依赖于对线程的精准控制与高效调度。掌握多线程技术,不仅关乎代码执行效率,更直接影响系统稳定性、资源利用率与用户体验。

本页面系统梳理了Java并发编程的核心知识体系,从线程生命周期管理、线程同步机制、线程池优化策略,到Java内存模型(JMM)、并发工具类实战应用,结合真实场景案例与高频面试题解析,帮助开发者构建完整的并发编程认知框架。

当前互联网应用普遍面临“高并发”挑战:单机QPS动辄数万,用户请求延迟需控制在毫秒级,资源竞争冲突频繁。若缺乏并发意识,轻则导致系统响应缓慢、吞吐量下降,重则引发死锁、数据不一致、服务雪崩等严重故障。因此,深入理解多线程原理,是避免“并发陷阱”、实现系统稳定性的关键保障。

本学习路径覆盖以下核心能力模块:

  • • 线程创建与生命周期管理(Thread/Runnable/Callable)
  • • 线程安全三大特性:原子性、可见性、有序性
  • • synchronized与Lock体系深度解析
  • • volatile关键字原理与内存语义
  • • 线程池参数调优与拒绝策略设计
  • • 并发工具类(CountDownLatch/CyclicBarrier/Phaser/ Semaphore)实战
  • • Java内存模型(JMM)与happens-before规则
  • • ThreadLocal原理、内存泄漏风险与最佳实践
  • • CAS原理与Atomic类家族应用
  • • 并发编程常见问题诊断与调优方法

建议学习顺序:先掌握线程基础与同步机制,再深入内存模型原理,最后通过实战项目巩固能力。每个知识点均配备可运行的代码示例与典型错误场景分析,帮助开发者从“能用”进阶到“用好”。无论你是初级工程师夯实基础,还是高级开发应对架构设计挑战,本内容均具高度实用价值。

一、线程基础:从创建到生命周期

在Java中,线程是CPU调度的最小单位。理解线程的创建方式与生命周期,是并发编程的第一步。

1.1 线程创建的三种主流方式

  • • 继承Thread类:重写run()方法,调用start()启动线程。缺点:单继承限制,无法继承其他类。
  • • 实现Runnable接口:将任务逻辑与线程分离,更灵活,推荐优先使用。
  • • 实现Callable接口 + Future:支持返回值与异常抛出,常配合线程池使用。

1.2 线程生命周期状态

Java线程有6种状态(Thread.State):

  1. NEW:线程刚创建,尚未调用start()。
  2. RUNNABLE:调用start()后进入此状态,包含“就绪”与“运行中”两种子状态。
  3. BLOCKED:等待获取synchronized锁时进入(排他锁阻塞)。
  4. WAITING:调用Object.wait()、Thread.join()等无参方法进入,需其他线程显式唤醒。
  5. TIMED_WAITING:调用Thread.sleep()、wait(long)、join(long)等带超时方法进入。
  6. TERMINATED:run()方法执行完毕或异常退出,线程结束。

1.3 线程中断机制详解

Thread.interrupt()仅设置中断标志位,不强制终止线程。正确中断方式:

  • • 在循环中检查Thread.currentThread().isInterrupted(),主动退出。
  • • 在阻塞方法(如sleep、wait)中,会抛出InterruptedException并清除中断状态。
  • • 避免使用已废弃的stop()、suspend()方法,易导致死锁。

示例:安全中断线程

public class SafeInterrupt implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                // 模拟业务处理
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // 恢复中断状态
                Thread.currentThread().interrupt();
                break;
            }
        }
        System.out.println("线程已安全退出");
    }
}

二、线程同步:保障数据一致性

多线程环境下,共享数据的并发访问可能导致脏读、丢失更新等问题。同步机制确保同一时刻仅一个线程访问临界区。

synchronized
Lock体系
Atomic类

2.1 synchronized关键字

三种使用形式:

  • • 实例方法:锁当前对象实例(this)
  • • 静态方法:锁当前类的Class对象
  • • 同步代码块:显式指定锁对象(推荐,粒度更细)

注意:锁对象必须是同一个实例,否则同步失效。

示例:银行转账同步实现

public class Account {
    private int balance = 1000;
    public void transfer(Account target, int amount) {
        synchronized (this) {  // 锁当前对象
            if (balance >= amount) {
                balance -= amount;
                target.balance += amount;
            }
        }
    }
}

2.2 ReentrantLock与读写锁

相比synchronized,Lock提供更灵活的锁控制:

  • • 尝试获取锁:tryLock()支持超时与中断响应
  • • 可中断锁获取:lockInterruptibly()
  • • 公平锁支持:new ReentrantLock(true)
  • • 读写分离:ReadWriteLock允许多个读线程并发

示例:使用读写锁优化缓存

public class Cache {
    private final Map map = new HashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    public V get(K key) {
        rwLock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }
    public void put(K key, V value) {
        rwLock.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

2.3 原子类与CAS机制

java.util.concurrent.atomic包提供无锁并发方案:

  • • 基础类:AtomicInteger/AtomicLong/AtomicBoolean
  • • 数组类:AtomicIntegerArray
  • • 引用类:AtomicReference
  • • 原子更新字段:AtomicIntegerFieldUpdater

底层基于Unsafe类的CAS(Compare-And-Swap)操作,避免线程阻塞,适合低竞争场景。

示例:计数器原子递增

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet(); // 原子操作
    }
    public int getValue() {
        return count.get();
    }
}

三、线程池:高效资源管理

频繁创建/销毁线程开销大,线程池复用线程,提升系统吞吐量与响应速度。

3.1 线程池核心参数解析

ThreadPoolExecutor构造参数:

  • • corePoolSize:核心线程数(常驻线程)
  • • maximumPoolSize:最大线程数
  • • keepAliveTime:非核心线程空闲存活时间
  • • unit:时间单位
  • • workQueue:任务队列(阻塞队列)
  • • threadFactory:线程创建工厂(可命名线程)
  • • handler:拒绝策略(队列满时处理方式)

3.2 四种拒绝策略

策略行为适用场景
AbortPolicy抛出RejectedExecutionException默认策略,快速失败
CallerRunsPolicy由调用线程执行任务允许任务延迟执行
DiscardPolicy直接丢弃任务允许任务丢失
DiscardOldestPolicy丢弃队列 oldest 任务保证新任务执行

3.3 阻塞队列类型对比

  • • ArrayBlockingQueue:有界数组队列,FIFO
  • • LinkedBlockingQueue:有界/无界链表队列(默认无界)
  • • SynchronousQueue:不存储元素,直接移交任务
  • • PriorityBlockingQueue:优先级队列
  • • DelayQueue:延迟队列

线程池推荐配置:

  • • CPU密集型任务:corePoolSize = CPU核心数 + 1
  • • IO密集型任务:corePoolSize = CPU核心数 × 2
  • • 混合型任务:拆分线程池分别处理

3.4 线程池生命周期管理

关键方法:

  • • shutdown():平滑关闭,不接受新任务,等待已提交任务完成
  • • shutdownNow():强制关闭,尝试中断线程,返回未执行任务
  • • awaitTermination():阻塞等待线程池终止

最佳实践:使用try-finally确保资源释放

ExecutorService pool = Executors.newFixedThreadPool(4);
try {
    // 提交任务
    pool.submit(() -> System.out.println("执行中"));
} finally {
    pool.shutdown();
}

四、并发工具类:提升开发效率

JDK并发包提供多种同步辅助类,简化复杂并发场景实现。

CountDownLatch
CyclicBarrier
Semaphore

4.1 CountDownLatch:倒计时门栓

用于等待多个线程完成后再继续执行(主线程等待子线程)。

典型场景:多线程初始化后启动服务

public class InitService {
    public void start() {
        int threadCount = 3;
        CountDownLatch latch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    // 模拟初始化
                    Thread.sleep(500);
                    System.out.println("服务初始化完成");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown();
                }
            }).start();
        }
        try {
            latch.await(); // 等待所有初始化完成
            System.out.println("所有服务启动完毕!");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

4.2 CyclicBarrier:循环屏障

多个线程相互等待,到达屏障点后继续执行(线程间同步)。

与CountDownLatch区别:CyclicBarrier可复用,支持屏障动作。

典型场景:多线程计算后汇总结果

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        int threadCount = 3;
        CyclicBarrier barrier = new CyclicBarrier(threadCount, () -> {
            System.out.println("所有线程到达屏障点,执行汇总");
        });
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    System.out.println("线程" + Thread.currentThread().getName() + "计算中...");
                    Thread.sleep(1000);
                    barrier.await(); // 等待其他线程
                    System.out.println("线程" + Thread.currentThread().getName() + "继续执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

4.3 Semaphore:信号量

控制同时访问特定资源的线程数量(限流)。

典型场景:数据库连接池、限流器

public class RateLimiter {
    private final Semaphore semaphore = new Semaphore(5); // 最多5个并发
    public void accessResource() {
        try {
            semaphore.acquire(); // 获取许可
            // 模拟资源访问
            System.out.println(Thread.currentThread().getName() + "正在访问资源");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release(); // 释放许可
        }
    }
}

4.4 Phaser:可重用屏障

支持动态注册/注销线程,支持多阶段同步。

相比CyclicBarrier更灵活,适用于多阶段任务协调。

五、Java内存模型:并发正确性的根基

JMM(Java Memory Model)定义了线程如何与主内存交互,保障并发程序的正确性。

5.1 JMM三大特性

  • • 原子性:由synchronized与Lock保证(不可分割操作)
  • • 可见性:由volatile、synchronized、final保证(线程间可见)
  • • 有序性:由happens-before规则保证(禁止指令重排序)

5.2 volatile关键字深度解析

作用:保证可见性 + 禁止指令重排序(不保证原子性)

典型应用:

  • • 状态标记:boolean flag = true;
  • • DCL单例模式
  • • 双重检查锁(Double-Checked Locking)

示例:安全的DCL单例

public class Singleton {
    private volatile static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // volatile防止重排序
                }
            }
        }
        return instance;
    }
}

5.3 happens-before规则

Java内存模型定义的12条happens-before规则中,最常用:

  1. • 程序顺序规则:单线程内,按代码顺序
  2. • 监视器锁规则:unlock() happens-before 后续的lock()
  3. • volatile变量规则:写 happens-before 后续的读
  4. • 线程启动规则:start() happens-before 线程内任何操作
  5. • 线程终止规则:线程内所有操作 happens-before join()返回
  6. • 中断规则:interrupt() happens-before 检测到中断
  7. • 传递性:A→B, B→C ⇒ A→C

5.4 内存屏障类型

屏障类型作用对应指令
LoadLoad禁止读操作重排序Load1; LoadLoad; Load2
StoreStore禁止写操作重排序Store1; StoreStore; Store2
LoadStore禁止读→写重排序Load; LoadStore; Store
StoreLoad禁止写→读重排序(最重)Store; StoreLoad; Load

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

理论需结合实践才能内化为能力。以下分析三个典型高并发问题及解决方案。

6.1 订单超卖问题

问题描述:库存10件,100人同时抢购,出现超卖(卖出12件)

原因分析:库存读取与扣减非原子操作,多个线程同时读到库存10,均执行成功

解决方案:

  • • 数据库层:使用UPDATE stock = stock - 1 WHERE id = ? AND stock > 0
  • • Redis层:Lua脚本保证原子性
  • • JVM层:synchronized或AtomicInteger

Redis Lua脚本示例:

local stock = redis.call('GET', KEYS[1])
if tonumber(stock) > tonumber(ARGV[1]) then
    redis.call('DECR', KEYS[1])
    return 1
else
    return 0
end

6.2 线程死锁诊断

死锁四要素:互斥、占有且等待、不可剥夺、循环等待

示例死锁代码:

public class DeadLock {
    private final Object lockA = new Object();
    private final Object lockB = new Object();
    public void method1() {
        synchronized (lockA) {
            Thread.sleep(100);
            synchronized (lockB) { ... } // 等待lockB
        }
    }
    public void method2() {
        synchronized (lockB) {
            Thread.sleep(100);
            synchronized (lockA) { ... } // 等待lockA
        }
    }
}

诊断工具:

  • • jstack -l [pid]:查看线程栈与死锁信息
  • • jvisualvm:图形化分析
  • • Arthas:在线诊断

预防策略:

  • • 统一锁顺序(避免循环等待)
  • • 使用tryLock()超时机制
  • • 减少锁持有时间
  • • 使用无锁数据结构

6.3 线程池拒绝策略实战

场景:秒杀系统瞬时流量峰值远超系统承载能力

配置方案:

  • • 核心线程数:8(满足基本处理能力)
  • • 最大线程数:16(突发流量扩容)
  • • 队列:ArrayBlockingQueue(100)(有界队列防OOM)
  • • 拒绝策略:CallerRunsPolicy(回压机制,避免雪崩)

效果:当系统过载时,调用线程(如HTTP请求线程)直接执行任务,自然降低请求速率,实现限流。

七、高频面试题:系统级准备

以下是开发者面试中关于多线程的高频问题与深度解答。

7.1 synchronized与ReentrantLock区别

  • • 语法:synchronized是关键字,Lock是接口
  • • 锁释放:synchronized自动释放,Lock需手动unlock()
  • • 功能:Lock支持尝试获取、可中断、公平锁、读写锁
  • • 性能:JDK6后synchronized优化显著,低竞争下性能相当
  • • 选择:简单同步用synchronized,高级需求用Lock

7.2 volatile与synchronized对比

特性volatilesynchronized
原子性不保证(除long/double)保证
可见性保证保证
有序性禁止重排序互斥执行
阻塞不阻塞阻塞线程
适用场景状态标记、双检锁复杂同步逻辑

7.3 线程池参数如何调优

调优三步法:

  1. • 监控指标:CPU使用率、线程数、队列长度、任务执行时间
  2. • 调整策略:根据监控数据分阶段调整参数
  3. • 验证效果:使用JMH进行基准测试

经验公式:corePoolSize = CPU核心数 × (1 + (IO耗时/CPU耗时))

7.4 ThreadLocal内存泄漏原因

ThreadLocalMap的Entry继承WeakReference,key为弱引用,value为强引用。

当ThreadLocal对象被回收后,key变为null,但value仍被强引用,若线程长期存活,导致value无法回收。

解决方案:

  • • 使用后及时调用remove()
  • • 避免在长生命周期线程中使用(如线程池)
  • • 自定义ThreadLocal子类重写remove()