java多线程详细知识

在现代软件架构中,并发编程已成为提升系统吞吐量与响应能力的核心能力之一。尤其在高并发服务、分布式系统、实时计算等场景下,掌握Java多线程详细知识不仅是开发工程师的基本功,更是构建高性能、高可用系统的基石。本文将系统性梳理Java并发编程体系,从基础概念到高级机制,结合真实项目经验与高频面试考点,帮助您构建完整的知识图谱。

随着多核CPU的普及与微架构演进(如Intel的SMT技术),单线程模型已无法充分发挥硬件潜力。Java作为主流企业级语言,其并发工具包提供了从底层线程控制到高层抽象API的全栈支持。理解这些机制,有助于避免常见陷阱(如死锁、活锁、饥饿),提升代码健壮性与可维护性。

需要特别注意的是,线程安全并非仅靠`synchronized`关键字就能保证。它涉及原子性、可见性、有序性三个维度的协调统一。例如,`volatile`关键字仅能保证可见性与有序性,却无法保证复合操作的原子性;而`AtomicInteger`通过CAS机制实现无锁线程安全,其性能通常优于`synchronized`,但需警惕ABA问题与自旋开销。

本文内容覆盖:线程生命周期、线程创建与启动、线程同步机制(synchronized、Lock、volatile)、线程通信(wait/notify、Condition)、线程池设计(ThreadPoolExecutor参数详解)、JUC核心组件(CountDownLatch、CyclicBarrier、Semaphore)、内存模型(happens-before规则、JMM抽象结构)、实战案例(生产者-消费者、读写缓存、限流熔断)等八大模块。每个主题均附有可运行代码示例与性能对比分析,确保知识可落地、可验证。

线程基础与生命周期

Java线程模型基于操作系统原生线程实现,遵循“1:1”映射模型(JVM线程 ↔ OS线程)。创建线程主要有三种方式:继承`Thread`类、实现`Runnable`接口、实现`Callable`接口。其中,`Runnable`与`Callable`更推荐使用,因其避免了单继承局限,且支持返回值与异常处理。

线程创建方式对比

  • Thread类:需继承并重写run()方法,适用于简单场景,但受限于Java单继承。
  • Runnable接口:将任务与线程分离,支持多实现,适用于资源共享场景(如多个线程共享同一任务对象)。
  • Callable接口:支持返回值(Future)与受检异常,需配合ExecutorService使用,适用于需要结果反馈的异步计算。

线程生命周期包含5种状态:NEW(创建后未启动)、RUNNABLE(就绪/运行中)、BLOCKED(等待监视器锁)、WAITING(无限期等待)、TIMED_WAITING(限时等待)。理解状态转换对排查线程问题至关重要。例如,当线程卡在`BLOCKED`状态时,通常表明存在锁竞争或死锁。

⚠️ 注意:调用`start()`方法才是启动线程的唯一正确方式,直接调用`run()`方法仅是普通方法调用,不会创建新线程。

线程优先级范围为1~10(Thread.MIN_PRIORITY ~ Thread.MAX_PRIORITY),默认为5(Thread.NORM_PRIORITY)。但需注意:线程优先级不具备可移植性,其行为依赖于操作系统调度器实现。例如在Linux中,Java线程优先级会被映射到NICE值,而不同发行版可能采用不同策略。

示例:线程状态观察
Thread t = new Thread(() -> {
    System.out.println("当前状态:" + Thread.currentThread().getState());
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
System.out.println("启动前:" + t.getState()); // NEW
t.start();
System.out.println("启动后:" + t.getState()); // RUNNABLE/BLOCKED/WAITING等

线程中断机制是协作式而非强制式。通过`interrupt()`方法设置中断标志位,线程需主动检查并处理中断(如抛出`InterruptedException`或检查`isInterrupted()`)。常见误区是忽略中断信号导致线程无法正常退出,尤其在循环中应定期检查中断状态。

⚠️ 警告:`stop()`、`suspend()`、`resume()`方法已被废弃,因其可能导致资源泄漏、死锁或数据不一致。例如`suspend()`会保留锁但暂停线程,其他线程无法获取锁,形成死锁。

线程同步与锁机制

线程同步的核心目标是保证原子性(操作不可分割)、可见性(修改对其他线程可见)、有序性(指令不被重排序)。Java通过`synchronized`、`volatile`、`Lock`等机制协同实现这些语义。

synchronized关键字详解

`synchronized`可修饰方法或代码块,底层通过监视器锁(Monitor)实现。对象头中包含锁标志位,JVM会根据竞争程度动态调整锁策略(偏向锁→轻量级锁→重量级锁)。

  • 实例方法锁:锁定当前实例对象(this),不同实例间互不影响。
  • 静态方法锁:锁定Class对象,全局唯一,所有实例共享。
  • 代码块锁:可自定义锁对象,粒度更细,推荐使用。
示例:线程安全计数器
public class SafeCounter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}

需警惕锁竞争升级:当多个线程频繁竞争同一锁时,JVM会将偏向锁升级为重量级锁,导致上下文切换开销剧增。可通过`-XX:+UseBiasedLocking`(JDK 8默认开启,JDK 15起默认关闭)调整策略。

volatile关键字特性

`volatile`确保变量修改对所有线程立即可见,并禁止指令重排序。适用于状态标记(如`volatile boolean running = true;`)与单例双重检查锁定(DCL)场景。

示例:单例模式DCL实现
public class Singleton {
    private static volatile Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

注意:`volatile`无法保证复合操作的原子性。例如`volatile int count = 0; count++;`仍需额外同步机制,因为`++`包含读-改-写三步操作。

Lock接口体系

`Lock`提供比`synchronized`更灵活的锁操作,支持尝试获取锁(`tryLock()`)、可中断获取锁(`lockInterruptibly()`)、公平锁等高级特性。核心实现类包括`ReentrantLock`(可重入锁)、`ReentrantReadWriteLock`(读写锁)。

示例:使用ReentrantLock实现线程安全队列
public class ThreadSafeQueue {
    private final List list = new ArrayList<>();
    private final Lock lock = new ReentrantLock();
    public void add(T item) {
        lock.lock();
        try {
            list.add(item);
        } finally {
            lock.unlock();
        }
    }
    public T remove() {
        lock.lock();
        try {
            return list.isEmpty() ? null : list.remove(0);
        } finally {
            lock.unlock();
        }
    }
}

读写锁适用于读多写少场景。`ReentrantReadWriteLock`允许多个读线程并发访问,但写线程独占访问。需注意:锁降级(写锁→读锁)是安全的,但锁升级(读锁→写锁)会导致死锁。

线程间通信机制

  • wait()/notify():基于对象监视器,需在同步块中调用,`wait()`释放锁,`notify()`唤醒等待线程。
  • Condition接口:`Lock`的配套工具,支持多个等待队列,功能更强大。例如`Condition`可实现精准唤醒(如生产者仅唤醒消费者)。
示例:Condition实现精准唤醒
class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();
    final Condition notEmpty = lock.newCondition();
    final Object[] items = new Object[100];
    int putptr, takeptr, count;
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();
            items[putptr] = x;
            putptr = (putptr + 1) % items.length;
            ++count;
            notEmpty.signal(); // 仅唤醒消费者
        } finally {
            lock.unlock();
        }
    }
}

线程池设计与实践

线程池通过复用线程避免频繁创建/销毁开销,是高并发系统的必备组件。`ThreadPoolExecutor`是核心实现类,其构造参数直接影响线程池行为:

ThreadPoolExecutor关键参数

参数 作用 典型值
corePoolSize 核心线程数 CPU核心数 + 1(IO密集型可更高)
maximumPoolSize 最大线程数 根据任务特性动态调整
keepAliveTime 非核心线程存活时间 60秒(空闲时释放)
workQueue 任务队列 LinkedBlockingQueue、ArrayBlockingQueue等
threadFactory 线程工厂 自定义命名(便于问题排查)
handler 拒绝策略 AbortPolicy、CallerRunsPolicy等

队列类型选择直接影响系统行为:

示例:自定义线程池配置
int cpuCount = Runtime.getRuntime().availableProcessors();
int corePoolSize = cpuCount + 1;
int maxPoolSize = cpuCount * 2;
ExecutorService pool = new ThreadPoolExecutor(
    corePoolSize,
    maxPoolSize,
    60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),
    new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);
⚠️ 警告:避免使用`Executors`工厂类创建线程池!其默认配置存在风险:
• `newFixedThreadPool`使用无界队列,易导致OOM
• `newCachedThreadPool`最大线程数为Integer.MAX_VALUE,易导致系统崩溃

拒绝策略选择需结合业务场景:

JUC核心工具类

`java.util.concurrent`(JUC)包提供了丰富的并发工具,大幅简化并发编程难度。核心组件包括同步器(Synchronizers)、并发集合(Collections)与原子变量(Atomic)。

同步器详解

CountDownLatch(倒计时器)

允许一个或多个线程等待其他线程完成操作。适用于主线程等待多个子任务完成后再继续执行的场景。

示例:多线程初始化完成通知
CountDownLatch latch = new CountDownLatch(3);
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
    pool.submit(() -> {
        try {
            // 模拟初始化操作
            Thread.sleep(1000);
            System.out.println("子任务完成");
        } finally {
            latch.countDown();
        }
    });
}
latch.await(); // 等待所有子任务完成
System.out.println("所有初始化完成,继续执行...");
pool.shutdown();

CyclicBarrier(循环栅栏)

允许一组线程互相等待,直到所有线程到达屏障点。可重用,适用于分阶段计算(如MapReduce)。

示例:分阶段计算求和
int[] data = {1,2,3,4,5,6,7,8};
int partSize = data.length / 2;
CyclicBarrier barrier = new CyclicBarrier(2, () -> {
    System.out.println("所有部分计算完成,合并结果");
});
for (int i = 0; i < 2; i++) {
    final int start = i * partSize;
    final int end = (i == 1) ? data.length : start + partSize;
    new Thread(() -> {
        int sum = 0;
        for (int j = start; j < end; j++) {
            sum += data[j];
        }
        System.out.println("部分和:" + sum);
        try {
            barrier.await(); // 等待其他线程
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();
}

Semaphore(信号量)

控制同时访问特定资源的线程数量,适用于限流场景(如数据库连接池)。

示例:数据库连接限流
Semaphore semaphore = new Semaphore(5); // 最多5个连接
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
    pool.submit(() -> {
        try {
            semaphore.acquire();
            // 获取连接并执行查询
            System.out.println(Thread.currentThread().getName() + " 获取连接");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
            System.out.println(Thread.currentThread().getName() + " 释放连接");
        }
    });
}

原子变量与CAS机制

原子变量通过CAS(Compare-And-Swap)实现无锁线程安全,避免了`synchronized`的上下文切换开销。核心类包括`AtomicInteger`、`AtomicReference`、`AtomicLong`等。

CAS原理:比较内存值与期望值,若相等则更新为新值,否则重试。需注意:

  • ABA问题:值从A→B→A,CAS误判为未修改。解决方案:使用`AtomicStampedReference`添加版本戳。
  • 自旋开销:高竞争下CAS重试频繁,导致CPU占用率高。解决方案:结合自适应自旋或降级为`synchronized`。
示例:AtomicStampedReference解决ABA
AtomicStampedReference ref = new AtomicStampedReference<>(100, 1);
// 线程1:修改值并更新时间戳
int[] stamp = {0};
int val = ref.get(stamp);
ref.compareAndSet(val, 200, stamp[0], stamp[0] + 1);
// 线程2:尝试修改(时间戳不匹配)
boolean success = ref.compareAndSet(100, 300, 1, 2); // 失败!

并发集合与高性能数据结构

集合类型 线程安全实现 适用场景
List `CopyOnWriteArrayList` 读多写少(如监听器列表)
Set `ConcurrentSkipListSet` 需要排序且高并发(如在线用户ID集合)
Map `ConcurrentHashMap` 高并发读写(如缓存、会话管理)
Queue `ConcurrentLinkedQueue` 无界队列(如异步任务分发)

`ConcurrentHashMap`采用分段锁(JDK 8起为CAS + synchronized)实现高并发,其核心优化包括:

示例:ConcurrentHashMap性能对比
// HashMap + Collections.synchronizedMap:性能差,全表锁
Map map1 = Collections.synchronizedMap(new HashMap<>());
// ConcurrentHashMap:高性能,分段锁
Map map2 = new ConcurrentHashMap<>();
map2.put("key", "value");
// CopyOnWriteArrayList:写时复制,适合读多写少
List list = new CopyOnWriteArrayList<>();
list.add("item");

Java内存模型(JMM)

Java内存模型(JMM)定义了线程与主内存之间的抽象关系,核心目标是保证并发程序的正确性。其三大特性:原子性(通过synchronized保证)、可见性(通过volatile、synchronized保证)、有序性(通过happens-before规则保证)。

happens-before规则

程序执行顺序不等于代码顺序,JMM通过happens-before定义操作间的可见性约束:

  1. 程序次序规则:单线程内,按代码顺序执行
  2. 监视器锁规则:解锁synchronized前的操作,对后续加锁可见
  3. volatile变量规则:写volatile变量前的操作,对后续读可见
  4. 线程启动规则:start()前的操作,对新线程可见
  5. 线程终止规则:线程内所有操作,对join()后可见
  6. 中断检测规则:interrupt()前的操作,对检测中断可见
  7. 对象终结规则:finalize()前的操作,对对象被回收前可见
  8. 传递性:A→B且B→C,则A→C
示例:volatile保证可见性
class FlagExample {
    private volatile boolean flag = false;
    private int data = 0;
    public void writer() {
        data = 42;      // 1. 写普通变量
        flag = true;    // 2. 写volatile变量
    }
    public void reader() {
        if (flag) {     // 3. 读volatile变量
            System.out.println(data); // 4. 必须读到42!
        }
    }
}

需注意:`volatile`禁止的是指令重排序,但仅保证对volatile变量的读写顺序。例如`a = 1; b = 2;`中,若b是volatile,则a=1一定在b=2之前执行,但其他线程可能先看到b=2而未看到a=1(除非通过其他机制保证)。

⚡ 实践建议:在初始化配置场景中,使用volatile修饰配置对象引用,确保其他线程读到完整配置。

实战案例与性能调优

理论知识需结合实践验证。以下通过三个典型场景,展示如何应用并发知识解决实际问题。

场景1:生产者-消费者模型(阻塞队列实现)

使用`BlockingQueue`简化生产者-消费者同步逻辑,避免手动管理wait/notify。

示例:基于ArrayBlockingQueue的生产者-消费者
public class ProducerConsumerDemo {
    private static final int QUEUE_SIZE = 10;
    private static final BlockingQueue queue = new ArrayBlockingQueue<>(QUEUE_SIZE);
    public static void main(String[] args) {
        // 生产者线程
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    queue.put(i);
                    System.out.println("生产:" + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        // 消费者线程
        new Thread(() -> {
            try {
                while (true) {
                    Integer value = queue.take();
                    System.out.println("消费:" + value);
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

优势:解耦生产与消费速率,队列满时自动阻塞生产者,队列空时自动阻塞消费者,无需手动同步。

场景2:读写缓存(ReentrantReadWriteLock)

适用于读多写少的缓存场景,提升并发吞吐量。

示例:线程安全的缓存实现
public class Cache {
    private final Map cache = new HashMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();
    public V get(K key) {
        readLock.lock();
        try {
            return cache.get(key);
        } finally {
            readLock.unlock();
        }
    }
    public void put(K key, V value) {
        writeLock.lock();
        try {
            cache.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
}

性能对比:在1000次读操作+10次写操作中,`ReentrantReadWriteLock`比`synchronized`快3倍以上。

场景3:限流熔断(信号量+线程池)

结合`Semaphore`与`ThreadPoolExecutor`实现服务降级,防止雪崩。

示例:带超时的限流调用
public class RateLimiterService {
    private final Semaphore semaphore = new Semaphore(50); // 50并发
    private final ExecutorService executor = new ThreadPoolExecutor(
        20, 100, 60L, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(200)
    );
    public String callRemoteService(String param) throws Exception {
        if (!semaphore.tryAcquire(100, TimeUnit.MILLISECONDS)) {
            throw new RuntimeException("服务过载,触发限流");
        }
        try {
            Future future = executor.submit(() -> {
                // 模拟远程调用
                Thread.sleep(50);
                return "result:" + param;
            });
            return future.get(200, TimeUnit.MILLISECONDS); // 200ms超时
        } finally {
            semaphore.release();
        }
    }
}

效果:当服务过载时,主动拒绝新请求,保护下游服务,同时通过超时机制避免线程长期阻塞。

性能调优关键指标

指标 优化方向 监控工具
线程上下文切换 减少线程数、使用无锁算法 `vmstat`、`perf`
锁竞争 减小锁粒度、使用CAS替代synchronized `jstack`、`jvisualvm`
内存占用 合理设置线程栈大小(-Xss) `jmap`、`MAT`
吞吐量 优化队列长度、调整核心线程数 `JMH`基准测试

高频问题与答疑

Q1:为什么volatile不能保证复合操作的原子性?

A:`volatile`仅保证单次读/写操作的原子性,而`count++`包含三步(读→改→写),中间可能被其他线程插入。例如:线程A读count=5,线程B也读count=5,两者都加1后写回6,导致丢失更新。解决方案:使用`AtomicInteger`或`synchronized`。

Q2:如何检测死锁?

A:通过`jstack`命令查看线程堆栈,若存在`BLOCKED`状态且循环等待资源,则可能死锁。生产环境可集成`ThreadMXBean`实时监控:

示例:死锁检测代码
ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] deadlockedThreads = bean.findDeadlockedThreads();
if (deadlockedThreads != null) {
    System.out.println("检测到死锁!");
    for (long id : deadlockedThreads) {
        System.out.println("线程ID:" + id);
    }
}

Q3:线程池中线程数量如何设置?

A:需结合任务类型:
• CPU密集型:线程数 ≈ CPU核心数(如`Runtime.getRuntime().availableProcessors()`)
• IO密集型:线程数 ≈ CPU核心数 × (1 + IO耗时/计算耗时)(通常为2倍)
• 混合型:拆分为CPU/IO子任务,分别配置线程池

Q4:为什么阿里巴巴Java开发手册禁止使用Executors创建线程池?

A:`Executors`工厂类存在严重隐患:
• `newFixedThreadPool`使用无界队列,任务堆积导致OOM
• `newCachedThreadPool`最大线程数为Integer.MAX_VALUE,高并发时创建过多线程导致系统崩溃
• 缺乏监控与调优能力
推荐直接使用`ThreadPoolExecutor`,显式指定队列容量与拒绝策略。

Q5:如何保证线程安全的单例模式?

A:推荐三种方案:
1. 静态内部类(推荐):利用JVM类加载机制保证线程安全
2. 枚举:天然单例,防止反射攻击
3. DCL + volatile:需正确实现双重检查锁定
避免使用`synchronized`修饰整个`getInstance()`方法(性能差)。

网友们还关心