Java 并发编程：核心原理、实战与避坑

（2）线程生命周期（6 种状态）

Java 线程状态定义在 Thread.State 枚举中，状态流转是面试核心：

• NEW：线程创建未启动（未调用 start()）；
• RUNNABLE：线程正在执行或等待 CPU 调度（包含操作系统的'就绪'和'运行'状态）；
• BLOCKED：线程阻塞等待锁（如 synchronized 未获取到锁时）；
• WAITING：线程无限期等待（如 Object.wait()、LockSupport.park()，需其他线程唤醒）；
• TIMED_WAITING：线程限时等待（如 Thread.sleep(1000)、Object.wait(1000)）；
• TERMINATED：线程执行完毕。

关键避坑：

• 线程调用 start() 后不能重复启动（会抛出 IllegalThreadStateException）；
• Thread.sleep() 不会释放锁，Object.wait() 会释放锁（需在 synchronized 代码块中调用）。

2. 同步机制：synchronized 与 Lock 详解

同步机制的核心是保证临界区代码原子执行，避免多线程并发冲突，Java 提供两种核心方案：

（1）synchronized（隐式锁，JVM 层面实现）

• 核心特性：可重入、非公平锁、自动释放锁（代码块执行完毕或异常时）；
• 锁的范围：
  • 修饰方法：锁对象为当前实例（非静态方法）或类对象（静态方法）；
  • 修饰代码块：锁对象为括号内的对象（如 this、Class 对象、自定义对象）；
• 底层原理：基于对象头的 Mark Word 实现，锁升级过程（无锁→偏向锁→轻量级锁→重量级锁）是性能优化的关键：
  • 偏向锁：单线程场景下避免锁竞争，提高效率；
  • 轻量级锁：多线程交替执行，通过 CAS 自旋获取锁，避免阻塞；
  • 重量级锁：多线程同时竞争，通过操作系统互斥量实现，会导致线程阻塞（性能较差）。

实战示例：synchronized 解决 i++ 线程安全问题

public class SynchronizedDemo {
    private int count = 0;

    // 修饰方法（锁当前实例）
    public synchronized void increment() {
        count++; // 临界区代码（原子执行）
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 启动 1000 个线程，每个线程执行 1000 次 increment
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            executor.submit(demo::increment);
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
        System.out.println("最终 count 值：" + demo.count); // 输出 1000000（线程安全）
    }
}

（2）Lock（显式锁，API 层面实现）

java.util.concurrent.locks.Lock 接口，核心实现类 ReentrantLock（可重入锁），相比 synchronized 更灵活：

• 核心特性：可重入、支持公平锁/非公平锁、可中断锁、超时获取锁、条件变量（Condition）；
• 核心方法：
  • lock()：获取锁（阻塞）；
  • tryLock()：尝试获取锁（非阻塞，返回 boolean）；
  • tryLock(long time, TimeUnit unit)：超时获取锁；
  • unlock()：释放锁（必须在 finally 中调用，避免死锁）；
• 适用场景：需要灵活控制锁（如超时重试、公平锁）、多条件等待（如生产者 - 消费者模型）。

实战示例：ReentrantLock 实现生产者 - 消费者模型

public class LockProducerConsumer {
    private final Lock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition(); // 非空条件
    private final Condition notFull = lock.newCondition(); // 非满条件
    private final Queue<Integer> queue = new LinkedList<>();
    private static final int CAPACITY = 10; // 队列容量

    // 生产者
    public void produce(int data) throws InterruptedException {
        lock.lock();
        try {
            // 队列满时等待
            while (queue.size() == CAPACITY) {
                notFull.await(); // 释放锁，等待 notFull 信号
            }
            queue.offer(data);
            System.out.println("生产者生产：" + data);
            notEmpty.signal(); // 唤醒消费者（队列非空）
        } finally {
            lock.unlock(); // 必须在 finally 释放锁
        }
    }

    // 消费者
    public Integer consume() throws InterruptedException {
        lock.lock();
        try {
            // 队列为空时等待
            while (queue.isEmpty()) {
                notEmpty.await(); // 释放锁，等待 notEmpty 信号
            }
            Integer data = queue.poll();
            System.out.println("消费者消费：" + data);
            notFull.signal(); // 唤醒生产者（队列非满）
            return data;
        } finally {
            lock.unlock();
        }
    }
}

（3）synchronized 与 ReentrantLock 对比选型

3. 线程池：核心原理与参数优化

线程池是并发编程的'性能利器'，其核心价值是复用线程、控制线程数量、减少线程创建销毁开销，避免'线程爆炸'（如无限制创建线程导致 OOM）。

（1）核心原理：ThreadPoolExecutor

Java 线程池的核心实现类是 ThreadPoolExecutor，构造函数参数决定线程池行为：

public ThreadPoolExecutor(int corePoolSize,      // 核心线程数（常驻线程，即使空闲也不销毁）
                          int maximumPoolSize,  // 最大线程数（核心线程 + 临时线程的总上限）
                          long keepAliveTime,   // 临时线程空闲存活时间
                          TimeUnit unit,        // keepAliveTime 的时间单位
                          BlockingQueue<Runnable> workQueue, // 任务阻塞队列（核心线程满时存储任务）
                          ThreadFactory threadFactory,       // 线程创建工厂（自定义线程名称、优先级等）
                          RejectedExecutionHandler handler)  // 任务拒绝策略（队列满 + 最大线程数时的处理方式）

（2）任务执行流程（必记）

1. 提交任务时，先判断核心线程是否空闲：若空闲则直接执行，否则创建核心线程；
2. 核心线程满时，将任务加入阻塞队列；
3. 队列满时，创建临时线程执行任务；
4. 临时线程满（达到 maximumPoolSize）且队列满时，触发拒绝策略。

（3）拒绝策略（4 种默认实现）

（4）常见线程池（Executors 工具类）

Executors 提供了 4 种预定义线程池，但生产环境不建议直接使用（存在 OOM 风险）：

• Executors.newFixedThreadPool(n)：固定核心线程数，无临时线程（maximumPoolSize=corePoolSize），队列无界（LinkedBlockingQueue）→ 队列满时 OOM；
• Executors.newCachedThreadPool()：核心线程数 0，临时线程无上限（maximumPoolSize=Integer.MAX_VALUE）→ 线程爆炸 OOM；
• Executors.newSingleThreadExecutor()：单核心线程，队列无界 → 队列满时 OOM；
• Executors.newScheduledThreadPool(n)：定时任务线程池，核心线程数 n，支持延迟/周期性执行任务。

（5）生产环境线程池配置优化（实战）

线程池参数需根据业务场景（CPU 密集型/IO 密集型）调整：

• CPU 密集型任务（如计算、排序）：线程数=CPU 核心数 +1（避免 CPU 空闲，充分利用核心）；
• IO 密集型任务（如数据库查询、网络请求）：线程数=CPU 核心数×2+1（IO 操作时线程阻塞，多线程可提高吞吐量）；

实战配置示例：

// 1. 获取 CPU 核心数
int cpuCoreNum = Runtime.getRuntime().availableProcessors();
// 2. 配置 IO 密集型线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    cpuCoreNum * 2,                      // 核心线程数
    cpuCoreNum * 2 + 1,                  // 最大线程数
    60L,                                 // 临时线程空闲存活时间
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),      // 有界队列（避免 OOM），容量根据业务调整
    new ThreadFactory() {                // 自定义线程工厂（便于问题排查）
        private final AtomicInteger count = new AtomicInteger(0);
        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("biz-thread-" + count.incrementAndGet());
            thread.setPriority(Thread.NORM_PRIORITY);
            return thread;
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略（IO 密集型允许延迟）
);

4. 并发工具类：CountDownLatch、CyclicBarrier、Semaphore

Java 并发包（java.util.concurrent）提供了多种工具类，简化复杂并发场景的开发：

（1）CountDownLatch（倒计时器）

• 核心功能：让主线程等待多个子线程执行完毕后再继续执行（不可重复使用）；
• 原理：初始化时指定计数器值，子线程执行完毕调用 countDown() 减 1，主线程调用 await() 阻塞，直到计数器为 0。

实战场景：主线程等待 3 个任务线程执行完毕

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3); // 计数器=3
        // 启动 3 个任务线程
        for (int i = 1; i <= 3; i++) {
            int taskId = i;
            new Thread(() -> {
                try {
                    System.out.println("任务" + taskId + "执行中...");
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown(); // 任务执行完毕，计数器减 1
                }
            }).start();
        }
        latch.await(); // 主线程阻塞，等待计数器为 0
        System.out.println("所有任务执行完毕，主线程继续执行");
    }
}

（2）CyclicBarrier（循环屏障）

• 核心功能：让多个线程到达某个'屏障'后阻塞，直到所有线程都到达屏障，再一起继续执行（可重复使用）；
• 区别于 CountDownLatch：CyclicBarrier 是'线程互相等待'，CountDownLatch 是'主线程等待子线程'；支持重置计数器（reset()）。

实战场景：3 个线程同时开始执行任务

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("所有线程已到达屏障，开始同步执行...");
        }); // 计数器=3，屏障触发时执行回调
        for (int i = 1; i <= 3; i++) {
            int threadId = i;
            new Thread(() -> {
                try {
                    System.out.println("线程" + threadId + "正在前往屏障...");
                    Thread.sleep(threadId * 1000); // 模拟不同到达时间
                    barrier.await(); // 到达屏障，阻塞等待其他线程
                    System.out.println("线程" + threadId + "开始执行任务");
                } catch (InterruptedException | BrokenBarrierException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
    }
}

（3）Semaphore（信号量）

• 核心功能：控制同时访问某个资源的线程数量（限流）；
• 原理：初始化时指定许可数，线程获取许可（acquire()）后才能访问资源，访问完毕释放许可（release()），许可数为 0 时线程阻塞。

实战场景：限制最多 2 个线程同时访问数据库连接

public class SemaphoreDemo {
    private static final Semaphore semaphore = new Semaphore(2); // 最多 2 个许可
    private static final List<String> dbConnections = Arrays.asList("conn1", "conn2", "conn3");

    public static void main(String[] args) {
        // 启动 5 个线程竞争访问数据库连接
        for (int i = 1; i <= 5; i++) {
            int threadId = i;
            new Thread(() -> {
                try {
                    semaphore.acquire(); // 获取许可（限流）
                    String conn = dbConnections.get(threadId % 3);
                    System.out.println("线程" + threadId + "获取连接：" + conn);
                    Thread.sleep(1000); // 模拟数据库操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    semaphore.release(); // 释放许可
                    System.out.println("线程" + threadId + "释放连接");
                }
            }).start();
        }
    }
}

三、并发编程常见坑点与避坑指南

1. 坑点 1：volatile 关键字的误用

• 错误认知：认为 volatile 能保证原子性（如 volatile int i=0; i++ 线程安全）；
• 正确认知：volatile 仅保证可见性和有序性，不保证原子性；
• 避坑方案：原子操作使用 AtomicInteger（CAS 实现），复杂逻辑使用 synchronized/Lock。

2. 坑点 2：线程池参数不合理导致 OOM

• 错误场景：使用 Executors.newFixedThreadPool()（无界队列），高并发下任务堆积导致 OOM；
• 避坑方案：
  • 自定义 ThreadPoolExecutor，使用有界队列（如 ArrayBlockingQueue）；
  • 合理设置队列容量和最大线程数，避免任务堆积；
  • 选择合适的拒绝策略（如 CallerRunsPolicy）。

3. 坑点 3：死锁问题

• 死锁条件：资源互斥、持有并等待、不可剥夺、循环等待；
• 实战案例：线程 A 持有锁 1，等待锁 2；线程 B 持有锁 2，等待锁 1；
• 避坑方案：
  • 统一锁获取顺序（如线程 A、B 都先获取锁 1，再获取锁 2）；
  • 使用 ReentrantLock.tryLock(time, unit) 超时获取锁，避免无限等待；
  • 定期检测死锁（如通过 jstack 命令分析线程堆栈）。

4. 坑点 4：synchronized 锁范围过大导致性能问题

• 错误场景：将整个方法加锁（如 public synchronized void method()），导致所有线程串行执行；
• 避坑方案：
  • 缩小锁范围（仅对临界区代码加锁）；
  • 使用更灵活的 Lock（如 ReentrantLock），支持非阻塞获取锁；
  • 无状态方法避免加锁（无需共享资源）。

四、并发编程黄金法则（必记）

1. 优先使用线程池，而非直接创建线程：复用线程、控制数量，避免 OOM 和性能开销；
2. 慎用 synchronized，灵活选择锁机制：简单场景用 synchronized，复杂场景用 ReentrantLock；
3. volatile 不保证原子性：原子操作优先用 JUC 原子类（AtomicXXX）；
4. 避免线程阻塞的过度使用：IO 密集型任务用异步编程（如 CompletableFuture），减少线程阻塞；
5. 并发问题排查工具：jstack（线程堆栈分析）、jconsole（线程监控）、Arthas（在线诊断）。

五、总结

Java 并发编程的核心是在保证线程安全的前提下，充分利用硬件资源提升性能。其底层依赖 JMM 解决可见性、原子性、有序性问题，上层通过线程、同步机制、线程池、并发工具类实现复杂并发场景。

学习并发编程的关键在于：

• 理解底层原理（JMM、锁机制），而非死记 API；
• 结合实战场景（如生产者 - 消费者、限流、任务同步），将技术落地；
• 避开常见坑点（如 volatile 误用、死锁、线程池 OOM），写出稳健的代码。

建议开发者在日常开发中，从简单场景（如线程池使用、synchronized 同步）入手，逐步深入复杂场景（如并发工具类、异步编程），同时养成'用工具排查并发问题'的习惯（如 jstack 分析死锁），最终掌握并发编程这一核心技能。