一、引言为什么并发编程如此重要在当今多核处理器普及的时代并发编程已成为Java开发者必须掌握的核心技能。无论是构建高并发的Web服务、实现实时数据处理系统还是开发响应式的桌面应用并发能力都直接决定了程序的性能和用户体验。然而并发编程也是一把双刃剑——它既能带来性能的飞跃也可能引入难以调试的线程安全问题。本文将从Java并发的基础概念出发逐步深入到高级实践涵盖线程管理、同步机制、并发工具类、性能优化等关键主题。通过5000字的系统讲解帮助读者建立完整的Java并发知识体系并掌握在实际项目中安全高效地使用并发编程的能力。二、Java并发编程基础2.1 进程与线程的区别在深入Java并发之前我们需要明确两个基本概念进程和线程。进程Process操作系统资源分配的基本单位每个进程都有独立的内存空间、文件句柄和系统资源。进程间的通信IPC成本较高。线程ThreadCPU调度的基本单位是进程内的执行单元。同一进程内的多个线程共享内存空间和资源通信成本低但需要处理同步问题。在Java中我们主要操作的是线程。每个Java程序至少有一个主线程main线程开发者可以创建额外的线程来并行执行任务。2.2 创建线程的三种方式Java提供了多种创建线程的方式每种方式都有其适用场景。2.2.1 继承Thread类public class MyThread extends Thread { Override public void run() { System.out.println(线程执行: Thread.currentThread().getName()); } public static void main(String[] args) { MyThread thread new MyThread(); thread.start(); // 启动线程 } }这种方式简单直接但由于Java是单继承继承Thread类会占用继承名额限制了类的扩展性。2.2.2 实现Runnable接口public class MyRunnable implements Runnable { Override public void run() { System.out.println(Runnable执行: Thread.currentThread().getName()); } public static void main(String[] args) { Thread thread new Thread(new MyRunnable()); thread.start(); } }这是更推荐的方式因为实现接口不会占用继承名额且任务逻辑与线程管理分离更符合面向对象设计原则。2.2.3 实现Callable接口带返回值import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; public class MyCallable implements CallableString { Override public String call() throws Exception { Thread.sleep(1000); return Callable执行完成; } public static void main(String[] args) throws Exception { FutureTaskString futureTask new FutureTask(new MyCallable()); Thread thread new Thread(futureTask); thread.start(); // 获取执行结果会阻塞直到任务完成 String result futureTask.get(); System.out.println(result); } }Callable接口允许线程返回结果并且可以抛出异常比Runnable更强大。通常与FutureTask或线程池配合使用。2.3 线程的生命周期Java线程在其生命周期中会经历多种状态NEW新建线程被创建但尚未启动RUNNABLE可运行线程正在JVM中执行或等待操作系统调度BLOCKED阻塞线程等待获取监视器锁WAITING等待线程无限期等待其他线程的特定动作TIMED_WAITING定时等待线程在指定时间内等待TERMINATED终止线程执行完毕理解这些状态及其转换条件对于调试并发问题至关重要。三、线程同步与锁机制3.1 线程安全问题根源当多个线程同时访问共享资源时如果没有适当的同步机制就可能出现数据不一致的问题。这主要源于原子性问题一个操作被中途打断可见性问题一个线程的修改对其他线程不可见有序性问题指令重排序导致执行顺序与预期不符3.2 synchronized关键字synchronized是Java中最基本的同步机制可以用于方法或代码块。3.2.1 同步方法public class Counter { private int count 0; // 同步实例方法 public synchronized void increment() { count; } // 同步静态方法 public static synchronized void staticMethod() { // 静态方法锁的是类对象 } }3.2.2 同步代码块public class FineGrainedLock { private final Object lock1 new Object(); private final Object lock2 new Object(); private int value1 0; private int value2 0; public void method1() { synchronized(lock1) { value1; } } public void method2() { synchronized(lock2) { value2; } } }同步代码块可以提供更细粒度的锁控制减少锁竞争提高并发性能。3.3 volatile关键字volatile确保变量的可见性和禁止指令重排序但不保证原子性。public class VolatileExample { private volatile boolean flag false; public void writer() { flag true; // 写操作对其他线程立即可见 } public void reader() { if (flag) { // 读操作总是读取最新值 // 执行操作 } } }volatile适用于一写多读的场景或者作为状态标志位。3.4 Java内存模型JMMJava内存模型定义了线程如何与内存交互以及线程间的通信规则。关键概念包括主内存所有线程共享的内存区域工作内存每个线程私有的内存区域happens-before原则定义操作之间的可见性关系理解JMM是掌握Java并发编程的基础它解释了为什么需要同步以及各种同步机制的工作原理。四、Java并发工具类4.1 Lock接口与ReentrantLockJava 5引入了java.util.concurrent.locks包提供了更灵活的锁机制。import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockExample { private final Lock lock new ReentrantLock(); private int count 0; public void increment() { lock.lock(); // 获取锁 try { count; // 可以在这里执行需要同步的操作 } finally { lock.unlock(); // 确保锁被释放 } } // 尝试获取锁避免死锁 public boolean tryIncrement() { if (lock.tryLock()) { try { count; return true; } finally { lock.unlock(); } } return false; } }ReentrantLock相比synchronized的优势可中断的锁获取超时获取锁公平锁与非公平锁选择可以绑定多个Condition4.2 读写锁ReadWriteLock读写锁允许多个读线程同时访问但写线程需要独占访问。import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class CacheK, V { private final MapK, V map new HashMap(); private final ReadWriteLock lock new ReentrantReadWriteLock(); public V get(K key) { lock.readLock().lock(); // 获取读锁 try { return map.get(key); } finally { lock.readLock().unlock(); } } public void put(K key, V value) { lock.writeLock().lock(); // 获取写锁 try { map.put(key, value); } finally { lock.writeLock().unlock(); } } }读写锁在读多写少的场景下能显著提升性能。4.3 原子类Atomic Classesjava.util.concurrent.atomic包提供了一系列原子操作类无需锁即可保证线程安全。import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; public class AtomicExample { private AtomicInteger counter new AtomicInteger(0); private AtomicReferenceString latestValue new AtomicReference(init); public void increment() { // 原子自增 counter.incrementAndGet(); // CAS操作 int oldValue, newValue; do { oldValue counter.get(); newValue oldValue 1; } while (!counter.compareAndSet(oldValue, newValue)); } public void updateValue(String newValue) { latestValue.set(newValue); } }原子类基于CASCompare-And-Swap实现性能远高于锁适用于计数器、状态标志等场景。4.4 CountDownLatch、CyclicBarrier和Semaphore4.4.1 CountDownLatch倒计时门闩import java.util.concurrent.CountDownLatch; public class CountDownLatchExample { public static void main(String[] args) throws InterruptedException { int threadCount 5; CountDownLatch latch new CountDownLatch(threadCount); for (int i 0; i threadCount; i) { new Thread(() - { try { // 模拟任务执行 Thread.sleep((long) (Math.random() * 1000)); System.out.println(Thread.currentThread().getName() 完成任务); } catch (InterruptedException e) { e.printStackTrace(); } finally { latch.countDown(); // 计数减1 } }).start(); } latch.await(); // 等待所有线程完成 System.out.println(所有任务完成继续执行主线程); } }4.4.2 CyclicBarrier循环屏障import java.util.concurrent.CyclicBarrier; public class CyclicBarrierExample { public static void main(String[] args) { int threadCount 3; CyclicBarrier barrier new CyclicBarrier(threadCount, () - { System.out.println(所有线程到达屏障执行屏障动作); }); for (int i 0; i threadCount; i) { final int threadId i; new Thread(() - { try { System.out.println(线程 threadId 到达屏障点1); barrier.await(); System.out.println(线程 threadId 到达屏障点2); barrier.await(); } catch (Exception e) { e.printStackTrace(); } }).start(); } } }4.4.3 Semaphore信号量import java.util.concurrent.Semaphore; public class SemaphoreExample { public static void main(String[] args) { // 限制同时只有3个线程可以访问资源 Semaphore semaphore new Semaphore(3); for (int i 0; i 10; i) { final int threadId i; new Thread(() - { try { semaphore.acquire(); // 获取许可 System.out.println(线程 threadId 获取资源); Thread.sleep(1000); // 模拟资源使用 System.out.println(线程 threadId 释放资源); } catch (InterruptedException e) { e.printStackTrace(); } finally { semaphore.release(); // 释放许可 } }).start(); } } }五、线程池与Executor框架5.1 为什么需要线程池直接创建线程的缺点线程创建和销毁开销大线程数量不受控制可能导致系统资源耗尽缺乏统一管理难以监控和调优线程池通过复用线程、控制并发数量、提供管理接口解决了这些问题。5.2 Executor框架核心组件Java并发包提供了完整的Executor框架Executor执行任务的接口ExecutorService扩展了Executor提供生命周期管理ThreadPoolExecutor最常用的线程池实现ScheduledExecutorService支持定时和周期性任务Future表示异步计算的结果5.3 创建线程池的几种方式5.3.1 使用Executors工厂方法import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ExecutorsExample { public static void main(String[] args) { // 固定大小线程池 ExecutorService fixedPool Executors.newFixedThreadPool(5); // 单线程线程池 ExecutorService singleThreadPool Executors.newSingleThreadExecutor(); // 缓存线程池根据需要创建新线程 ExecutorService cachedPool Executors.newCachedThreadPool(); // 定时任务线程池 ScheduledExecutorService scheduledPool Executors.newScheduledThreadPool(3); // 提交任务 fixedPool.submit(() - System.out.println(任务执行)); // 定时任务 scheduledPool.scheduleAtFixedRate(() - { System.out.println(定时任务执行); }, 0, 1, TimeUnit.SECONDS); // 关闭线程池 fixedPool.shutdown(); } }5.3.2 自定义ThreadPoolExecutorimport java.util.concurrent.*; public class CustomThreadPool { public static void main(String[] args) { int corePoolSize 5; // 核心线程数 int maxPoolSize 10; // 最大线程数 long keepAliveTime 60L; // 空闲线程存活时间 TimeUnit unit TimeUnit.SECONDS; BlockingQueueRunnable workQueue new ArrayBlockingQueue(100); ThreadFactory threadFactory Executors.defaultThreadFactory(); RejectedExecutionHandler handler new ThreadPoolExecutor.AbortPolicy(); ThreadPoolExecutor executor new ThreadPoolExecutor( corePoolSize, maxPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler ); // 提交任务 for (int i 0; i 20; i) { final int taskId i; executor.execute(() - { System.out.println(执行任务: taskId , 线程: Thread.currentThread().getName()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }); } // 优雅关闭 executor.shutdown(); try { if (!executor.awaitTermination(60, TimeUnit.SECONDS)) { executor.shutdownNow(); } } catch (InterruptedException e) { executor.shutdownNow(); } } }5.4 线程池参数详解理解ThreadPoolExecutor的7个核心参数corePoolSize核心线程数即使空闲也不会被回收