首页|基础|同步|线程池|工具|内存模型|调优|实战|FAQ|周边

java多线程编程

从线程创建到高并发架构设计的系统性实践指南

⚡ 线程基础:构建并发认知的基石

在java多线程编程的世界里,理解线程的本质是开启高并发开发的第一把钥匙。线程(Thread)是操作系统能够进行运算调度的最小单位,被包含在进程之中,是进程中的实际运作单位。Java语言通过java.lang.Thread类和java.lang.Runnable接口提供了对线程的原生支持。

创建线程主要有三种方式:

  1. 继承Thread类并重写run()方法
  2. 实现Runnable接口并传递给Thread构造器
  3. 使用Callable与Futures支持返回值与异常处理

以下为典型示例:

// 方式一:继承Thread类
class MyThread extends Thread {
    public void run() {
        System.out.println("线程执行中:" + Thread.currentThread().getName());
    }
}
new MyThread().start();
// 方式二:实现Runnable接口
class MyTask implements Runnable {
    public void run() {
        System.out.println("任务执行:" + Thread.currentThread().getName());
    }
}
new Thread(new MyTask()).start();
// 方式三:使用Lambda(Java 8+)
new Thread(() -> {
    System.out.println("Lambda线程:" + Thread.currentThread().getName());
}).start();

值得注意的是,直接调用run()方法不会启动新线程,仅作为普通方法调用;必须通过start()方法触发JVM创建新线程并执行run()逻辑。

线程的生命周期包括:

线程优先级范围为1(MIN_PRIORITY)~10(MAX_PRIORITY),默认为5(NORM_PRIORITY)。但需注意:优先级仅作为调度提示,不保证执行顺序,且不同操作系统对优先级映射不一致,过度依赖可能导致调度不公平。

线程安全问题源于多个线程并发访问共享可变状态,典型场景包括:计数器累加、缓存更新、集合修改等。若缺乏同步机制,将出现AABA问题、丢失更新、可见性缺失等风险。

⚙️ 同步机制:保障线程安全的核心手段

线程安全的核心在于控制对共享资源的并发访问。Java提供了多层次的同步机制,从语言级到类库级,覆盖不同场景需求。

〔1〕synchronized关键字

synchronized是Java内置的轻量级同步原语,可修饰方法或代码块。其本质是通过对象监视器(Monitor)实现互斥访问:

// 修饰实例方法:锁当前实例对象
public synchronized void updateCounter() { ... }
// 修饰静态方法:锁Class对象
public static synchronized void resetAll() { ... }
// 修饰代码块:显式指定锁对象
private final Object lock = new Object();
synchronized(lock) {
    // 临界区
}

需警惕锁粗化(Lock Coarsening)与锁消除(Lock Elision)优化:JIT编译器可能自动合并连续加锁/解锁操作,或在逃逸分析确认对象仅单线程访问时移除锁。

〔2〕volatile关键字

volatile确保变量的可见性与禁止指令重排序,适用于状态标记、双检锁单例等场景。但volatile不保证原子性,因此count++等复合操作仍需额外同步:

private volatile boolean initialized = false;
public void init() {
    if (!initialized) {
        synchronized(this) {
            if (!initialized) {
                setup(); // 禁止重排序:setup()在initialized=true前执行
                initialized = true;
            }
        }
    }
}

〔3〕显式锁:ReentrantLock与ReadWriteLock

ReentrantLock提供比synchronized更灵活的控制:

private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
public void put(E e) throws InterruptedException {
    lock.lock();
    try {
        while (queue.size() == capacity)
            notFull.await();
        queue.add(e);
        notEmpty.signal();
    } finally {
        lock.unlock();
    }
}

ReadWriteLock允许多个读线程并发访问,但写线程独占,适用于读多写少场景(如缓存、配置中心):

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock r = rwLock.readLock();
private final Lock w = rwLock.writeLock();
public String readConfig() {
    r.lock();
    try { return config; }
    finally { r.unlock(); }
}
public void updateConfig(String newConfig) {
    w.lock();
    try { config = newConfig; }
    finally { w.unlock(); }
}

⚡ 线程池:高效复用与资源管控

频繁创建/销毁线程带来显著开销。线程池通过复用线程、控制并发数、管理任务队列,实现资源高效利用。

〔1〕ThreadPoolExecutor核心参数

参数说明典型值
corePoolSize核心线程数(常驻线程)CPU核数+1
maximumPoolSize最大线程数根据任务类型调整
keepAliveTime非核心线程存活时间60秒
unit时间单位TimeUnit.SECONDS
workQueue任务队列LinkedBlockingQueue等
threadFactory线程工厂(可命名线程)new NamedThreadFactory()
handler拒绝策略AbortPolicy等

常见拒绝策略:

〔2〕推荐线程池配置

《阿里巴巴Java开发手册》建议:

线程池不允许使用Executors创建,应通过ThreadPoolExecutor显式指定参数,避免资源耗尽风险。

典型安全创建方式:

int core = Runtime.getRuntime().availableProcessors();
BlockingQueue queue = new LinkedBlockingQueue<>(1024);
ThreadFactory factory = new ThreadFactoryBuilder()
    .setNameFormat("biz-worker-%d")
    .setDaemon(true)
    .build();
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    core, core * 2, 60L, TimeUnit.SECONDS,
    queue, factory, new ThreadPoolExecutor.CallerRunsPolicy()
);

不同任务类型建议配置:

⚙️ 并发工具类:JUC核心组件详解

〔1〕CountDownLatch:倒计时门栓

允许一个或多个线程等待其他线程完成操作。典型场景:主线程等待所有子任务初始化完成。

CountDownLatch latch = new CountDownLatch(3);
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
    pool.execute(() -> {
        try {
            Thread.sleep(500);
            System.out.println("子任务完成");
        } catch (InterruptedException e) { }
        finally { latch.countDown(); }
    });
}
latch.await(); // 阻塞直到countDown为0
System.out.println("所有任务完成");

〔2〕CyclicBarrier:循环栅栏

一组线程互相等待到达屏障点后一起继续执行。支持重用与屏障动作。

CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有线程就位,准备下一阶段");
});
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
    pool.execute(() -> {
        try {
            Thread.sleep((long)(Math.random()*1000));
            barrier.await(); // 等待其余线程
            System.out.println(Thread.currentThread().getName() + "通过栅栏");
        } catch (Exception e) { e.printStackTrace(); }
    });
}

〔3〕Semaphore:信号量

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

Semaphore semaphore = new Semaphore(5); // 5个许可
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
    pool.execute(() -> {
        try {
            semaphore.acquire();
            System.out.println("获取资源,当前可用:" + semaphore.availablePermits());
            Thread.sleep(2000);
        } catch (InterruptedException e) { }
        finally { semaphore.release(); }
    });
}

〔4〕ConcurrentHashMap:高并发哈希表

Java 8中采用Node数组+链表/红黑树结构,通过CAS+synchronized保证线程安全:

性能远超Hashtable与Collections.synchronizedMap,推荐作为高并发场景首选。

〔5〕CompletableFuture:异步编程利器

支持函数式编程风格的异步编排,弥补Future阻塞等待缺陷:

CompletableFuture future = CompletableFuture
    .supplyAsync(() -> {
        return "Hello";
    })
    .thenApplyAsync(s -> s + " World")
    .thenComposeAsync(s -> CompletableFuture
        .supplyAsync(() -> s + "!")
    );
String result = future.join(); // 非阻塞获取结果
System.out.println(result); // Hello World!

常用方法:

〔内存模型:理解并发本质的关键〕

Java内存模型(JMM)定义了线程如何与主内存交互,解决可见性、原子性、有序性三大问题。

核心规则:

典型重排序场景:

  1. 编译器优化重排序(如常量传播、死代码消除)
  2. 指令级并行重排序(CPU乱序执行)
  3. 内存系统重排序(缓存刷新延迟)

防止重排序手段:

双检锁单例的正确写法:

public class Singleton {
    private static volatile Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // 1.分配内存 2.初始化 3.赋值引用
                }
            }
        }
        return instance;
    }
}

若无volatile,可能发生指令重排:1→3→2,导致其他线程获取未初始化对象。

⚡ 性能调优:从监控到调优的完整闭环

〔1〕监控工具链

〔2〕常见性能陷阱

〔3〕调优实践案例

某电商订单处理系统,单机TPS从2000提升至8000:

  1. 将HashMap替换为ConcurrentHashMap
  2. 订单状态机采用状态模式+事件驱动,减少synchronized使用
  3. 线程池配置:core=CPU×1.5,队列容量=1000,拒绝策略= CallerRunsPolicy
  4. 使用CompletableFuture异步落库+批量提交
  5. 引入本地缓存(Caffeine)降低DB压力

〔实战案例:构建高并发系统〕

〔1〕秒杀系统设计要点

〔2〕日志异步化方案

使用Disruptor(高性能无锁队列)替代传统日志框架同步写盘:

RingBuffer ringBuffer = RingBuffer.createSingleProducer(
    Event::new, 1024 * 1024
);
Disruptor disruptor = new Disruptor<>(Event::new, 1024, DaemonThreadFactory.INSTANCE);
disruptor.handleEventsWith((event, sequence, endOfBatch) -> {
    logger.info("写入日志:{}", event.getMessage());
});
disruptor.start();
// 生产者发布事件
ringBuffer.publishEvent((event, sequence) -> event.setMessage("用户登录"));

实测日志写入延迟从15ms降至0.8ms,吞吐量提升10倍。

〔3〕分布式ID生成器(Snowflake改进版)

基于时间戳+机器ID+序列号,使用AtomicLong保证线程安全:

public class IdGenerator {
    private static final long TWEPOCH = 1288834974657L;
    private static final long WORKER_ID_BITS = 5L;
    private static final long DATA_CENTER_ID_BITS = 5L;
    private static final long SEQUENCE_BITS = 12L;
    private final long workerId;
    private final long dataCenterId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;
    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp)
            throw new RuntimeException("时钟回拨");
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & ((1 << SEQUENCE_BITS) - 1);
            if (sequence == 0) timestamp = tilNextMillis(lastTimestamp);
        } else sequence = 0L;
        lastTimestamp = timestamp;
        return ((timestamp - TWEPOCH) << (WORKER_ID_BITS + DATA_CENTER_ID_BITS + SEQUENCE_BITS))
             | (dataCenterId << (WORKER_ID_BITS + SEQUENCE_BITS))
             | (workerId << SEQUENCE_BITS)
             | sequence;
    }
}

FAQ|高频问题深度解答

Q:为什么局部变量是线程安全的?

A:局部变量存储在线程栈中,每个线程拥有独立的栈空间,不存在共享,故天然线程安全。但若局部变量引用了共享对象(如传入的参数),仍需同步。

Q:ArrayList是否线程安全?如何替代?

A:ArrayList非线程安全。替代方案:

  • 单线程:使用ArrayList(性能最优)
  • 多线程读多写少:Collections.synchronizedList(new ArrayList<>())
  • 高并发读多写少:CopyOnWriteArrayList(写时复制)
  • 高并发读写:ConcurrentSkipListMap或自定义分段锁

Q:如何排查死锁?

A:步骤如下:

  1. jps -l获取Java进程ID
  2. jstack [pid]查看线程堆栈
  3. 搜索Found one Java-level deadlock
  4. 分析阻塞关系:线程A持有锁1等待锁2,线程B持有锁2等待锁1

预防策略:

  • 统一加锁顺序(如按对象哈希码排序)
  • 使用tryLock+超时重试
  • 减少锁持有时间(缩小同步块范围)
  • 使用无锁数据结构(如ConcurrentHashMap)

Q:synchronized与ReentrantLock性能对比?

A:Java 6起synchronized大幅优化(偏向锁、轻量级锁),在无竞争场景性能优于ReentrantLock。但ReentrantLock在高竞争、长持锁时间下更优,且提供更丰富功能。

实测数据(1000万次加锁/解锁):

方案耗时(ms)吞吐量(万次/秒)
synchronized28035.7
ReentrantLock(公平)45022.2
ReentrantLock(非公平)31032.3

建议:简单场景用synchronized;需中断、超时、公平性控制时用ReentrantLock。