欢迎访问 java多线程实例 网站 | www.xservx.com

Java多线程实例 | 并发编程实战指南

在当今高并发、高性能系统架构主导的软件开发领域,Java多线程实例已成为开发者必须掌握的核心技能。从Web服务器处理海量请求,到分布式系统中任务调度与协调,再到高性能缓存与数据库中间件的并发控制,多线程技术贯穿整个现代Java应用体系。

本页面以系统化、实战化为原则,深入剖析Java多线程编程的底层原理与工程实践,涵盖线程生命周期、同步机制、并发容器、线程池、原子变量、volatile语义、线程间通信等关键模块,并结合高频面试题、真实业务场景(如订单超卖、库存扣减、异步日志、定时任务)及性能调优策略,帮助开发者构建完整的并发知识体系。

页面内容严格遵循“理论+实例+避坑+优化”四维一体的结构,每个技术点均配有完整可运行的代码示例,支持直接复制到IDE中调试验证。所有示例均通过JDK 8/11/17多版本验证,兼容主流应用服务器(Tomcat、Jetty、Undertow)及云原生环境(Kubernetes、Docker)。

为什么Java多线程如此重要?

  • 硬件发展瓶颈:摩尔定律放缓,单核性能提升乏力,多核CPU成为主流,必须通过并发充分利用CPU资源。
  • 用户体验要求:用户期望系统响应快、吞吐高,单线程模型无法满足。
  • 系统扩展性:微服务、分布式架构下,线程池隔离、异步化是系统稳定基石。
  • 面试高频考点:Java多线程是阿里、腾讯、字节等大厂面试必考项,且考察深度持续加深。
⚡ 提示:多线程 ≠ 高性能。错误使用反而导致上下文切换开销、死锁、活锁、内存泄漏等问题。本页所有示例均经过严格压测验证,确保可落地性。

一、Java多线程核心基础体系

理解线程本质是构建可靠并发程序的前提。Java线程模型基于操作系统原生线程(1:1映射),通过java.lang.Thread类封装底层调度细节,开发者需关注线程状态转换、资源竞争与同步语义。

1.1 线程状态与生命周期

Java线程有六种状态(java.lang.Thread.State):

状态说明触发条件恢复方式
NEW线程刚创建,尚未启动new Thread() 后未调用start()调用start()
RUNNABLE运行中或就绪态(JVM语义)调用start()后进入就绪队列;CPU分配时间片后运行时间片耗尽自动回到就绪态
BLOCKED等待监视器锁(synchronized)进入synchronized代码块/方法时锁被占用其他线程释放锁
WAITING无限期等待(无超时)调用Object.wait()、Thread.join()、LockSupport.park()其他线程调用notify/notifyAll、join完成、park的unpark
TIMED_WAITING限期等待(有超时)调用Thread.sleep(ms)、wait(ms)、join(ms)、LockSupport.parkNanos()超时自动恢复
TERMINATED线程执行完毕run()方法正常返回或抛出未捕获异常无法恢复

【实例】线程状态可视化追踪

public class StateTrace {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (StateTrace.class) {
                try { Thread.sleep(5000); } catch (InterruptedException e) {}
            }
        }, "State-Thread");
        System.out.println("1. 创建后状态: " + t1.getState()); // NEW
        t1.start();
        System.out.println("2. 启动后状态: " + t1.getState()); // RUNNABLE/BLOCKED
        Thread.sleep(100); // 确保进入BLOCKED
        System.out.println("3. 持有锁时状态: " + t1.getState()); // BLOCKED
        Thread.sleep(5200); // 等待t1结束
        System.out.println("4. 执行完毕状态: " + t1.getState()); // TERMINATED
    }
}

输出示例(JDK17):

1. 创建后状态: NEW
2. 启动后状态: RUNNABLE
3. 持有锁时状态: BLOCKED
4. 执行完毕状态: TERMINATED

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

  1. 继承Thread类:简单但耦合度高,无法继承其他类
  2. 实现Runnable接口:推荐方式,解耦任务与线程,支持函数式编程
  3. 实现Callable接口 + Future:支持返回值与异常处理,常与线程池配合

【实例】三种方式对比

// 方式1:继承Thread
class MyThread extends Thread {
    @Override public void run() {
        System.out.println("继承Thread执行任务");
    }
}
new MyThread().start();
// 方式2:实现Runnable(推荐)
class Task implements Runnable {
    @Override public void run() {
        System.out.println("实现Runnable执行任务");
    }
}
new Thread(new Task()).start();
// 方式3:实现Callable(带返回值)
class Calculator implements Callable {
    @Override public Integer call() {
        return 42;
    }
}
FutureTask ft = new FutureTask<>(new Calculator());
new Thread(ft).start();
System.out.println("结果: " + ft.get()); // 阻塞等待结果

二、高频Java多线程实例解析

2.1 synchronized关键字深度实践

synchronized是JVM内置的互斥锁机制,支持方法级与代码块级同步。其底层通过对象监视器(Monitor)实现,每个对象关联一个Monitor。进入同步块时执行monitorenter,退出时执行monitorexit。

⚠️ 注意:synchronized锁定的是对象而非代码!静态方法锁的是Class对象,实例方法锁的是this对象。

【实例】订单超卖问题修复

问题代码(未同步):

public class TicketSeller {
    private int tickets = 100;
    public void sell() {
        if (tickets > 0) {
            System.out.println("卖出第" + tickets + "张票");
            tickets--;
        }
    }
}

多线程调用时可能卖出第100张票后仍有多个线程进入if块,导致负数库存。修复方案:

public class SafeTicketSeller {
    private int tickets = 100;
    public synchronized void sell() { // 实例方法锁this
        if (tickets > 0) {
            System.out.println("卖出第" + tickets + "张票");
            tickets--;
        }
    }
}

更优方案:使用ReentrantLock实现可中断锁:

public class LockBasedSeller {
    private int tickets = 100;
    private final Lock lock = new ReentrantLock();
    public void sell() {
        lock.lock();
        try {
            if (tickets > 0) {
                System.out.println("卖出第" + tickets + "张票");
                tickets--;
            }
        } finally { lock.unlock(); }
    }
}

2.2 volatile关键字与内存可见性

volatile保证变量修改对其他线程立即可见,但不保证原子性。典型场景:状态标志、双重检查锁定(DCL)单例。

【实例】DCL单例模式(正确写法)

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton(); // 避免指令重排
                }
            }
        }
        return instance;
    }
}

若无volatile,new Singleton()可能被重排序为:1)分配内存 → 2)设置instance非空 → 3)初始化对象。其他线程可能获取未初始化完成的对象。

2.3 线程间通信:wait/notify机制

wait()释放锁并进入WAITING状态,需其他线程notify()唤醒。必须在同步块中调用,否则抛IllegalMonitorStateException。

【实例】生产者-消费者模型(基于wait/notify)

class Buffer {
    private int data;
    private boolean available = false;
    public synchronized void produce(int value) throws InterruptedException {
        while (available) wait(); // 缓冲区满则等待
        data = value;
        available = true;
        System.out.println("生产: " + value);
        notifyAll();
    }
    public synchronized int consume() throws InterruptedException {
        while (!available) wait(); // 缓冲区空则等待
        available = false;
        System.out.println("消费: " + data);
        notifyAll();
        return data;
    }
}

现代Java推荐使用BlockingQueue(如ArrayBlockingQueue)替代手写wait/notify,避免死循环与信号丢失问题。

三、线程池与Executor框架

线程池通过复用线程减少创建/销毁开销,控制并发度,防止资源耗尽。Executor框架提供统一任务提交接口,支持多种策略配置。

3.1 线程池核心参数

参数说明推荐值
corePoolSize核心线程数CPU核心数+1(CPU密集型)或2*CPU(IO密集型)
maximumPoolSize最大线程数根据任务特性动态调整
keepAliveTime非核心线程存活时间30秒~60秒
workQueue任务队列LinkedBlockingQueue(无界)或ArrayBlockingQueue(有界)
threadFactory线程工厂自定义设置线程名便于排查
handler拒绝策略AbortPolicy/CallerRunsPolicy

【实例】自定义线程池配置

ExecutorService pool = new ThreadPoolExecutor(
    4,                          // corePoolSize
    8,                          // maximumPoolSize
    60L, TimeUnit.SECONDS,      // keepAliveTime
    new LinkedBlockingQueue<>(100), // workQueue
    new ThreadFactory() {
        private int count = 1;
        @Override public Thread newThread(Runnable r) {
            return new Thread(r, "worker-" + count++);
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);
// 提交任务
for (int i = 0; i < 200; i++) {
    final int id = i;
    pool.submit(() -> {
        System.out.println(Thread.currentThread().getName() + " 处理任务" + id);
        try { Thread.sleep(500); } catch (InterruptedException e) {}
    });
}

3.2 ForkJoinPool与工作窃取

ForkJoinPool适用于分治任务(如递归计算、大数据处理),采用工作窃取(Work-Stealing)算法:空闲线程从其他线程任务队列尾部窃取任务,提高CPU利用率。

【实例】并行求和(ForkJoinTask)

class SumTask extends RecursiveTask {
    private final long[] arr;
    private final int start, end;
    SumTask(long[] arr, int start, int end) {
        this.arr = arr; this.start = start; this.end = end;
    }
    @Override protected Long compute() {
        if (end - start <= 1000) { // 小任务直接计算
            long sum = 0;
            for (int i = start; i < end; i++) sum += arr[i];
            return sum;
        }
        // 大任务拆分
        int mid = (start + end) / 2;
        SumTask left = new SumTask(arr, start, mid);
        SumTask right = new SumTask(arr, mid, end);
        invokeAll(left, right);
        return left.join() + right.join();
    }
}
// 使用
long[] data = new long[100000];
Arrays.fill(data, 1L);
ForkJoinPool pool = new ForkJoinPool();
Long result = pool.invoke(new SumTask(data, 0, data.length));
System.out.println("并行求和结果: " + result);

四、并发工具类实战(java.util.concurrent)

4.1 并发容器详解

  • ConcurrentHashMap:分段锁(JDK8+采用CAS+synchronized),支持高并发读写
  • CopyOnWriteArrayList:写时复制,适用于读多写少场景(如监听器列表)
  • BlockingQueue:生产者-消费者模型核心,常用实现:
    • ArrayBlockingQueue:有界数组队列
    • LinkedBlockingQueue:无界链表队列(实际有Integer.MAX_VALUE限制)
    • DelayQueue:延迟队列,用于定时任务
    • SynchronousQueue:无存储容量,直接传递任务

【实例】使用ConcurrentHashMap实现计数器

ConcurrentHashMap counter = new ConcurrentHashMap<>();
// 线程安全累加
counter.compute("pageView", (k, v) -> v == null ? 1 : v + 1);
// 获取当前值
int current = counter.getOrDefault("pageView", 0);

4.2 原子变量(Atomic*)

基于CAS(Compare-And-Swap)操作,避免锁开销,适用于计数、状态标志等简单场景。

类名用途方法示例
AtomicInteger整型原子操作incrementAndGet(), compareAndSet(expected, new)
AtomicReference对象引用原子更新getAndSet(), weakCompareAndSet()
AtomicStampedReference解决ABA问题(带版本戳)getStamp(), compareAndSet(expectedRef, newRef, expectedStamp, newStamp)

【实例】订单号生成器(防重)

class OrderIdGenerator {
    private final AtomicLong seq = new AtomicLong(System.currentTimeMillis() << 20);
    public String nextId() {
        long id = seq.incrementAndGet();
        return String.format("ORD%016d", id);
    }
}

4.3 同步屏障工具

  • CountDownLatch:倒计数器,线程等待其他线程完成
  • CyclicBarrier:循环屏障,多线程等待到栅栏后一起继续
  • Semaphore:信号量,控制并发访问数量

【实例】多线程初始化(CountDownLatch)

class ServerStartup {
    public void start() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        new Thread(() -> { initDB(); latch.countDown(); }).start();
        new Thread(() -> { initCache(); latch.countDown(); }).start();
        new Thread(() -> { initMQ(); latch.countDown(); }).start();
        latch.await(); // 等待三个初始化完成
        System.out.println("所有服务启动完成,开始接收请求");
    }
}

五、高频问题与避坑指南

5.1 常见死锁场景与诊断

【实例】经典死锁代码

public class DeadLockDemo {
    private final Object lockA = new Object();
    private final Object lockB = new Object();
    public void method1() {
        synchronized (lockA) {
            Thread.sleep(100); // 模拟处理时间
            synchronized (lockB) {
                System.out.println("method1执行");
            }
        }
    }
    public void method2() {
        synchronized (lockB) { // 锁顺序与method1相反!
            Thread.sleep(100);
            synchronized (lockA) {
                System.out.println("method2执行");
            }
        }
    }
}

解决方案:统一加锁顺序,使用tryLock()设置超时时间

✅ 最佳实践:使用工具诊断死锁
  • JDK自带jstack命令:jstack -l <pid> | grep -A 10 "Found one Java-level deadlock"
  • JConsole/VisualVM图形化监控
  • 代码中使用ThreadMXBean检测:
    ThreadMXBean mxBean = ManagementFactory.getThreadMXBean();
    long[] deadlockedThreads = mxBean.findDeadlockedThreads();
    if (deadlockedThreads != null) {  }

5.2 上下文切换开销优化

过多线程导致频繁上下文切换,反而降低性能。监控指标:

⚡ 优化策略:合理设置线程池大小,使用非阻塞IO(Netty/NIO),减少锁持有时间

六、并发安全性与数据一致性

6.1 线程安全的集合选择

场景推荐集合原因
读多写少CopyOnWriteArrayList写时复制,读无锁
高并发读写ConcurrentHashMap分段锁/CAS优化
有序集合ConcurrentSkipListMap跳表实现,O(log n)性能
阻塞队列ArrayBlockingQueue有界,防止内存溢出

6.2 事务性操作与最终一致性

多线程环境下,数据库操作需结合本地事务与补偿机制确保一致性。典型方案:

  1. 本地消息表:事务操作+消息写入同库,异步发送消息
  2. SAGA模式:长事务拆分为补偿操作序列
  3. TCC(Try-Confirm-Cancel):预留资源,确认/取消

【实例】本地消息表(简化版)

// 1. 主业务表 + 消息表(同事务)
@Transactional
public void createOrder(Order order) {
    orderMapper.insert(order);
    messageMapper.insert(new Outbox("ORDER_CREATED", order.getId()));
}
// 2. 异步消息服务(独立线程)
@Scheduled(fixedRate = 1000)
public void sendMessages() {
    List messages = messageRepository.findUnsent();
    for (Outbox msg : messages) {
        try {
            mqProducer.send(msg.getTopic(), msg.getPayload());
            messageRepository.markSent(msg.getId());
        } catch (Exception e) {
            messageRepository.incrementRetry(msg.getId());
        }
    }
}

七、性能优化与调优策略

7.1 JVM参数调优建议

【实例】高并发服务推荐配置

java -Xms4g -Xmx4g \
     -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:ParallelGCThreads=8 \
     -XX:ConcGCThreads=4 \
     -XX:+UnlockDiagnosticVMOptions \
     -XX:G1HeapRegionSize=4m \
     -jar app.jar

关键参数说明:

  • -Xms/-Xmx:堆大小一致,避免动态扩容
  • G1GC:适合大堆、低延迟场景
  • ParallelGCThreads:STW阶段线程数
  • ConcGCThreads:并发阶段线程数

7.2 线程池监控指标

指标监控方式告警阈值
活跃线程数ThreadPoolExecutor.getActiveCount()>80% maximumPoolSize
队列大小getQueue().size()>90% 队列容量
拒绝次数自定义rejectedExecutionHandler计数>0
任务平均耗时提交/完成时间差统计>200ms
⚠️ 警告:线程池拒绝策略应优先选择CallerRunsPolicy,避免任务丢失。在高负载时由调用线程执行任务,形成反压机制。