Java并发编程深度指南：多线程

原创已于 2025-09-21 20:35:00 修改 · 741 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#java #并发编程

于 2025-09-21 20:34:15 首次发布

并发编程专栏收录该内容

4 篇文章

订阅专栏

一、前言：为什么多线程如此重要？

在现代软件开发中，多线程编程已成为必备的核心技能。随着多核处理器的普及和分布式系统的发展，能否编写高效、安全的并发程序直接决定了应用程序的性能和稳定性。Java作为企业级开发的主流语言，提供了丰富而强大的并发API，掌握这些技术不仅有助于日常开发，更是面试中的高频考点。

本文将系统性地讲解Java多线程的核心概念、实战技巧和面试要点，帮助读者构建完整的知识体系。

二、Java多线程基础概念

2.1 进程与线程的区别

进程：操作系统资源分配的基本单位，拥有独立的内存空间
线程：CPU调度的基本单位，共享进程资源，切换开销小

2.2 线程的创建方式

// 1. 继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

// 2. 实现Runnable接口（推荐）
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}

// 3. 实现Callable接口（可获取返回值）
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
}

// 4. 使用线程池（生产环境推荐）
ExecutorService executor = Executors.newFixedThreadPool(10);

2.3 线程生命周期

NEW：新建状态
RUNNABLE：可运行状态
BLOCKED：阻塞状态
WAITING：等待状态
TIMED_WAITING：超时等待状态
TERMINATED：终止状态

三、线程安全与同步机制

3.1 临界区与竞态条件

当多个线程同时访问共享资源时，如果没有正确的同步措施，会导致数据不一致问题。

3.2 synchronized关键字

// 同步方法
public synchronized void syncMethod() {
    // 临界区代码
}

// 同步代码块
public void method() {
    synchronized(this) {
        // 临界区代码
    }
}

// 静态方法同步
public static synchronized void staticSyncMethod() {
    // 临界区代码
}

3.3 volatile关键字

保证变量的可见性和禁止指令重排序，但不保证原子性。

private volatile boolean flag = false;

3.4 Java锁体系

3.4.1 ReentrantLock

private final ReentrantLock lock = new ReentrantLock();

public void method() {
    lock.lock();
    try {
        // 临界区代码
    } finally {
        lock.unlock();
    }
}

3.4.2 读写锁（ReadWriteLock）

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

public void read() {
    rwLock.readLock().lock();
    try {
        // 读操作
    } finally {
        rwLock.readLock().unlock();
    }
}

public void write() {
    rwLock.writeLock().lock();
    try {
        // 写操作
    } finally {
        rwLock.writeLock().unlock();
    }
}

四、Java并发工具类

4.1 CountDownLatch

等待多个线程完成后再执行主线程

CountDownLatch latch = new CountDownLatch(3);

// 工作线程
latch.countDown();

// 主线程
latch.await();

4.2 CyclicBarrier

让一组线程到达屏障点时被阻塞，直到最后一个线程到达

CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有线程已就位");
});

// 线程中调用
barrier.await();

4.3 Semaphore

控制同时访问特定资源的线程数量

Semaphore semaphore = new Semaphore(5); // 允许5个线程同时访问

semaphore.acquire();
try {
    // 使用资源
} finally {
    semaphore.release();
}

4.4 Exchanger

两个线程间交换数据

Exchanger<String> exchanger = new Exchanger<>();

// 线程1
String data1 = exchanger.exchange("Data from thread1");

// 线程2
String data2 = exchanger.exchange("Data from thread2");

五、线程池深入解析

5.1 为什么使用线程池？

降低资源消耗：减少线程创建和销毁的开销
提高响应速度：任务到达时无需等待线程创建
提高线程可管理性：统一分配、监控和调优

5.2 ThreadPoolExecutor核心参数

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,     // 核心线程数
    maximumPoolSize,  // 最大线程数
    keepAliveTime,    // 空闲线程存活时间
    unit,             // 时间单位
    workQueue,        // 工作队列
    threadFactory,    // 线程工厂
    handler           // 拒绝策略
);

5.3 四种拒绝策略

AbortPolicy：抛出RejectedExecutionException（默认）
CallerRunsPolicy：由调用线程执行该任务
DiscardPolicy：直接丢弃任务
DiscardOldestPolicy：丢弃队列最前面的任务

5.4 Executors工具类提供的线程池

newFixedThreadPool：固定大小线程池
newCachedThreadPool：可缓存线程池
newSingleThreadExecutor：单线程线程池
newScheduledThreadPool：定时任务线程池

六、原子操作类

Java提供了java.util.concurrent.atomic包，解决原子性问题

// 原子整型
AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet(); // 原子自增

// 原子引用
AtomicReference<String> atomicRef = new AtomicReference<>("初始值");

// CAS操作
boolean success = atomicInt.compareAndSet(expect, update);