Java并发编程：从基础到高级实战

        在现代软件开发中，并发编程已成为不可或缺的核心技能。随着多核处理器的普及和分布式系统的发展，能否编写高效、线程安全的并发程序直接决定了应用程序的性能和可靠性。Java作为一门成熟的企业级编程语言，提供了丰富的并发编程工具和API，但同时也带来了复杂性和各种潜在的陷阱。

         本文将系统性地介绍Java并发编程的各个方面，从基本概念到高级实践，从底层原理到实际应用，帮助开发者全面掌握并发编程技能。我们将通过大量实际代码示例和详细注释，展示如何避免常见的并发问题，构建高性能、线程安全的应用程序。

1.并发编程的基本概念

1.1.线程与进程的区别

• 进程：

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。比如我们打开windows的任务管理器可以看到有多少进行在我们计算机上运行。

进程的特性：

• 独立性：进程之间相互隔离，一个进程崩溃通常不会影响其他进程
• 资源开销：创建和销毁进程开销较大，因为需要分配和回收系统资源
• 通信复杂：进程间通信(IPC)需要特定机制，如管道、信号、共享内存等

• 线程:

线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间做切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。Java程序天生是读线程的程序，哪怕启用一个main方法。

线程的特性：

• 共享资源：线程可以访问所属进程的所有资源
• 轻量级：创建和销毁线程的开销远小于进程
• 通信简单：线程间可以通过共享内存直接通信

          我们可以通过ThreadMXBean中的dumpAllThreads方法返来看一个Java程序都有哪些线程:

// 执行main方法
public static void main(String[] args) {ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);for(ThreadInfo threadInfo : threadInfos){System.out.println("Thread Id:" + threadInfo.getThreadId() + " Thread Name :[" + threadInfo.getThreadName() + "]");}}// 控制台打印结果
Thread Id:6 Thread Name :[Monitor Ctrl-Break]
Thread Id:5 Thread Name :[Attach Listener]
Thread Id:4 Thread Name :[Signal Dispatcher]
Thread Id:3 Thread Name :[Finalizer]
Thread Id:2 Thread Name :[Reference Handler]
Thread Id:1 Thread Name :[main]Process finished with exit code 0

        可以看出执行一个mian方法是由多个线程同时执行的。

1.2.并发与并行的区别

       并发(Concurrency)和并行(Parallelism)**是经常被混淆的两个概念，它们在Java并发编程中有着明确的区别：

• 并发：

并发是指系统具有处理多个任务的能力，这些任务在时间上是重叠的，但不一定是同时执行的。在单核CPU上通过时间片轮转实现的多线程就是典型的并发。并发强调的是任务的组织和结构，是一种逻辑上的"同时"。

• 并行：

并行是指系统具有同时执行多个任务的能力，这需要多核或多处理器的硬件支持。并行关注的是任务的执行和性能提升，是一种物理上的真正同时。比如4C8G能做到并行处理4个任务。

      Rob Pike的经典描述很好地阐释了两者的区别：

并发是同一时间应对(dealing with)多件事情的能力

并行是同一时间动手做(doing)多件事情的能力

举例来说：

并发：一个服务员同时照看多张餐桌，通过快速切换服务实现"同时"服务的效果

并行：多个服务员各自独立照看不同的餐桌，真正同时提供服务

        在Java中，我们通过Thread类、synchronized等实现并发控制，而通过ForkJoinPool、parallelStream()等API实现并行计算。现代高并发系统通常需要同时考虑这两个方面：良好的并发设计保证程序正确性，合理的并行执行提高系统吞吐量。

1.3.Java中的线程模型

线程模型是用户线程和内核线程之间的关联方式，常见的线程模型有这三种：

1. 一对一（一个用户线程对应一个内核线程）
2. 多对一（多个用户线程映射到一个内核线程）
3. 多对多（多个用户线程映射到多个内核线程）

为了帮助我们的理解，我们讲以上三种线程模型具象化：

        Java线程模型经历了多次演进，目前采用的是基于操作系统原生线程的一对一模型。这意味着每个Java线程都直接对应一个操作系统线程，由操作系统内核负责线程调度和管理。Java线程的生命周期包括以下状态：

1. 新建(NEW)：线程对象刚被创建，但尚未启动。
2. 可运行(RUNNABLE)：线程正在JVM中执行或等待操作系统资源。
3. 阻塞(BLOCKED)：线程等待获取监视器锁以进入同步块/方法。
4. 等待(WAITING)：线程无限期等待其他线程执行特定操作。
5. 超时等待(TIMED_WAITING)：线程在指定时间内等待。
6. 终止(TERMINATED)：线程执行完毕或异常退出。

为了方便理解，列出JVM进程内部和线程的模型：

2.线程安全问题

• 竞态条件

指程序的正确性依赖于线程执行时序的情况。当多个线程访问共享资源且至少有一个线程修改该资源时，如果缺乏适当的同步，就可能出现竞态条件。

• 数据竞争

这个是竞态条件的一种特殊形式，发生在两个或多个线程同时访问同一内存位置，且至少有一个是写操作，且这些操作没有正确的同步。

• 死锁、活锁与饥饿

死锁(Deadlock)是指两个或多个线程互相持有对方需要的资源，导致所有线程都无法继续执行的状态。死锁发生的四个必要条件：

1. 互斥条件：资源一次只能被一个线程占用
2. 占有并等待：线程持有至少一个资源，同时等待获取其他线程占用的资源
3. 不可抢占：已分配给线程的资源不能被其他线程强行夺取
4. 循环等待：存在一个线程的循环等待链

3.Java中的并发工具

• synchronized关键字

synchronized是Java中最基本的同步机制，它可以确保多个线程不会同时执行某个代码块或方法。synchronized提供了原子性和可见性保证，即被synchronized保护的代码块在同一时间只能有一个线程执行，且线程在退出同步块时对共享变量的修改会立即对其他线程可见。

synchronized实例方法使用对象实例作为锁，静态方法使用类的Class对象作为锁，而同步代码块可以指定任意对象作为锁,synchronized的三种使用方式：

1. 实例方法同步
2. 静态方法同步
3. 同步代码块

public class SynchronizedExample {private int count = 0;private static int staticCount = 0;private final Object lock = new Object();// 1. 实例方法同步public synchronized void increment() {count++;}// 2. 静态方法同步public static synchronized void staticIncrement() {staticCount++;}// 3. 同步代码块public void incrementWithBlock() {// 一些非同步代码synchronized (lock) { // 使用特定对象作为锁count++;}// 更多非同步代码}public static void main(String[] args) throws InterruptedException {SynchronizedExample example = new SynchronizedExample();Thread t1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();SynchronizedExample.staticIncrement();example.incrementWithBlock();}});Thread t2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();SynchronizedExample.staticIncrement();example.incrementWithBlock();}});t1.start();t2.start();t1.join();t2.join();System.out.println("Instance count: " + example.count); // 2000System.out.println("Static count: " + staticCount); // 2000}
}

• volatile关键字

volatile是比synchronized更轻量级的同步机制，它确保变量的可见性和有序性，但不保证原子性。当一个字段被声明为volatile时：

1. 任何线程对该变量的修改都会立即写入主内存
2. 任何线程读取该变量时都会直接从主内存读取，而不是使用缓存
3. 禁止指令重排序优化

public class VolatileExample {private volatile boolean flag = false;public void writer() {flag = true; // 写volatile变量}public void reader() {if (flag) { // 读volatile变量System.out.println("Flag is true");}}public static void main(String[] args) {VolatileExample example = new VolatileExample();Thread writer = new Thread(example::writer);Thread reader = new Thread(example::reader);writer.start();reader.start();}
}

• ReentrantLock与ReadWriteLock

 ReentrantLock是java.util.concurrent.locks包中的可重入互斥锁，它提供了比synchronized更灵活的锁操作：

• 可中断的锁获取
• 超时获取锁
• 公平锁与非公平锁选择
• 多个条件变量

import java.util.concurrent.locks.ReentrantLock;public class ReentrantLockExample {private final ReentrantLock lock = new ReentrantLock();private int count = 0;public void increment() {lock.lock(); // 获取锁try {count++;} finally {lock.unlock(); // 确保锁被释放}}public static void main(String[] args) throws InterruptedException {ReentrantLockExample example = new ReentrantLockExample();Thread t1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});Thread t2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});t1.start();t2.start();t1.join();t2.join();System.out.println("Final count: " + example.count); // 2000}
}

ReadWriteLock接口及其实现ReentrantReadWriteLock实现了读写分离的锁策略，适用于读多写少的场景：

• 读锁是共享的，多个线程可以同时持有读锁
• 写锁是独占的，同一时间只能有一个线程持有写锁
• 写锁可以降级为读锁，但读锁不能升级为写锁

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReadWriteLockExample {private final ReadWriteLock rwLock = new ReentrantReadWriteLock();private String data = "Initial Data";public String readData() {rwLock.readLock().lock();try {return data;} finally {rwLock.readLock().unlock();}}public void writeData(String newData) {rwLock.writeLock().lock();try {data = newData;} finally {rwLock.writeLock().unlock();}}// 锁降级示例public void lockDowngrade(String newData) {rwLock.writeLock().lock();try {// 独占写权限data = newData;// 在释放写锁前获取读锁rwLock.readLock().lock();} finally {rwLock.writeLock().unlock(); // 释放写锁，降级为读锁}try {System.out.println("Data after downgrade: " + data);} finally {rwLock.readLock().unlock();}}
}

•  java.util.concurrent包中的工具

java.util.concurrent包提供了丰富的并发工具类，可以大致分为以下几类:

1. 原子变量类：如AtomicInteger、AtomicLong等，提供原子操作
2. 锁和条件：如ReentrantLock、Condition等
3. 并发集合：如ConcurrentHashMap、CopyOnWriteArrayList等
4. 线程池：如ExecutorService、ThreadPoolExecutor等
5. 同步辅助类：如CountDownLatch、CyclicBarrier、Semaphore等

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;public class ConcurrentToolsExample {private static final int THREAD_COUNT = 10;private static final CountDownLatch startLatch = new CountDownLatch(1);private static final CountDownLatch endLatch = new CountDownLatch(THREAD_COUNT);private static final AtomicInteger counter = new AtomicInteger(0);public static void main(String[] args) throws InterruptedException {ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);for (int i = 0; i < THREAD_COUNT; i++) {executor.execute(() -> {try {startLatch.await(); // 等待主线程发令// 模拟工作Thread.sleep((long) (Math.random() * 1000));counter.incrementAndGet();endLatch.countDown(); // 完成工作} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}System.out.println("Starting workers...");startLatch.countDown(); // 发令开始endLatch.await(); // 等待所有工作完成System.out.println("All workers completed. Counter: " + counter.get());executor.shutdown();}
}

4.线程池与任务调度

• Executor框架

Java的Executor框架将任务提交与任务执行解耦，提供了线程池管理的标准化方法。使用线程池可以避免频繁创建和销毁线程的开销，提高系统性能。Executors提供了多种预配置的线程池。框架的核心接口包括：

• Executor：简单的执行接口
• ExecutorService：扩展了Executor，添加了生命周期管理方法
• ScheduledExecutorService：支持延迟和定期任务
• ThreadPoolExecutor：可配置的线程池实现
• Executors：工厂类，提供创建线程池的便捷方法

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;public class ExecutorFrameworkExample {public static void main(String[] args) {// 创建固定大小的线程池ExecutorService executor = Executors.newFixedThreadPool(5);// 提交10个任务for (int i = 0; i < 10; i++) {final int taskId = i;executor.execute(() -> {System.out.println("Executing task " + taskId + " on " + Thread.currentThread().getName());try {Thread.sleep(1000); // 模拟任务执行时间} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}// 优雅关闭线程池executor.shutdown();try {if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {executor.shutdownNow();}} catch (InterruptedException e) {executor.shutdownNow();Thread.currentThread().interrupt();}}
}

• ThreadPoolExecutor的使用与配置

ThreadPoolExecutor是线程池的核心实现类，提供了丰富的配置选项：

• 核心线程数(corePoolSize)
• 最大线程数(maximumPoolSize)
• 线程空闲时间(keepAliveTime)
• 工作队列(workQueue)
• 线程工厂(threadFactory)
• 拒绝策略(handler)

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class ThreadPoolConfigExample {public static void main(String[] args) {// 创建自定义线程池ThreadPoolExecutor executor = new ThreadPoolExecutor(2, // 核心线程数4, // 最大线程数60, // 空闲线程存活时间TimeUnit.SECONDS,new ArrayBlockingQueue<>(2), // 工作队列容量new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略);// 提交任务for (int i = 0; i < 10; i++) {final int taskId = i;executor.execute(() -> {System.out.println("Task " + taskId + " executed by " + Thread.currentThread().getName());try {Thread.sleep(2000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}// 监控线程池状态monitorThreadPool(executor);// 关闭线程池executor.shutdown();}private static void monitorThreadPool(ThreadPoolExecutor executor) {new Thread(() -> {while (!executor.isTerminated()) {System.out.println("Pool size: " + executor.getPoolSize());System.out.println("Active threads: " + executor.getActiveCount());System.out.println("Completed tasks: " + executor.getCompletedTaskCount());System.out.println("Queue size: " + executor.getQueue().size());try {Thread.sleep(1000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}).start();}
}

•  ScheduledExecutorService的定时任务调度

ScheduledExecutorService接口扩展了ExecutorService，支持延迟和周期性任务执行。scheduleAtFixedRate以固定频率执行任务，而scheduleWithFixedDelay保证任务执行完成后的固定延迟。 

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledTaskExample {public static void main(String[] args) throws InterruptedException {ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);// 延迟执行scheduler.schedule(() -> {System.out.println("Delayed task executed after 2 seconds");}, 2, TimeUnit.SECONDS);// 固定速率执行（不考虑任务执行时间）scheduler.scheduleAtFixedRate(() -> {System.out.println("Fixed rate task executed at " + System.currentTimeMillis());try {Thread.sleep(1000); // 模拟任务执行时间} catch (InterruptedException e) {Thread.currentThread().interrupt();}}, 0, 2, TimeUnit.SECONDS);// 固定延迟执行（考虑任务执行时间）scheduler.scheduleWithFixedDelay(() -> {System.out.println("Fixed delay task executed at " + System.currentTimeMillis());try {Thread.sleep(1000); // 模拟任务执行时间} catch (InterruptedException e) {Thread.currentThread().interrupt();}}, 0, 2, TimeUnit.SECONDS);// 运行一段时间后关闭Thread.sleep(10000);scheduler.shutdown();}
}

5.并发集合类

• ConcurrentHashMap

ConcurrentHashMap是线程安全的哈希表实现，通过分段锁或CAS+synchronized(Java 8+)实现高并发访问。

import java.util.concurrent.ConcurrentHashMap;public class ConcurrentHashMapExample {public static void main(String[] args) {ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();// 并发安全的putIfAbsentmap.putIfAbsent("key1", 1);// 原子性更新map.compute("key1", (k, v) -> v == null ? 1 : v + 1);// 搜索String result = map.search(1, (k, v) -> v > 0 ? "found" : null);System.out.println("Search result: " + result);// 遍历map.forEach(2, (k, v) -> System.out.println("Key: " + k + " Value: " + v + " on " + Thread.currentThread().getName()));// 归约int sum = map.reduceValues(2, Integer::sum);System.out.println("Sum of values: " + sum);}
}

• CopyOnWriteArrayList

CopyOnWriteArrayList是线程安全的List实现，通过在修改时创建底层数组的新副本来实现并发安全，适合读多写少的场景。由于写操作需要复制整个数组，CopyOnWriteArrayList不适合写操作频繁的场景。

import java.util.concurrent.CopyOnWriteArrayList;public class CopyOnWriteArrayListExample {public static void main(String[] args) {CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();// 添加元素（创建新数组）list.add("Item1");list.add("Item2");// 迭代器使用快照，不受后续修改影响new Thread(() -> {list.forEach(item -> {System.out.println("Iterating: " + item);try {Thread.sleep(1000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}).start();// 修改不影响正在进行的迭代list.add("Item3");list.remove("Item1");}
}

• BlockingQueue及其实现类

BlockingQueue是支持阻塞操作的队列接口，常用于生产者-消费者模式。BlockingQueue提供了多种插入和移除方法，包括立即返回、抛出异常、阻塞等待和超时等待等不同行为。常见实现包括：

• ArrayBlockingQueue：有界数组实现
• LinkedBlockingQueue：可选有界链表实现
• PriorityBlockingQueue：优先级排序的无界队列
• SynchronousQueue：不存储元素的特殊队列
• DelayQueue：元素延迟出队的无界队列

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;public class BlockingQueueExample {public static void main(String[] args) {BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);// 生产者new Thread(() -> {try {queue.put("Item1");queue.put("Item2");boolean offered = queue.offer("Item3", 1, TimeUnit.SECONDS);System.out.println("Item3 offered: " + offered);offered = queue.offer("Item4", 1, TimeUnit.SECONDS); // 等待1秒后失败System.out.println("Item4 offered: " + offered);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();// 消费者new Thread(() -> {try {Thread.sleep(1500); // 让生产者先填充队列System.out.println("Polled: " + queue.poll());System.out.println("Polled: " + queue.poll());System.out.println("Polled: " + queue.poll());String item = queue.poll(2, TimeUnit.SECONDS); // 等待2秒System.out.println("Polled after wait: " + item);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}
}

6.原子操作与CAS

• AtomicInteger、AtomicLong等原子类

java.util.concurrent.atomic包提供了一系列原子变量类，如AtomicInteger、AtomicLong、AtomicBoolean等，它们通过CAS(Compare-And-Swap)指令实现原子操作。AtomicInteger适合低并发下的原子计数，而LongAdder在高并发下性能更好，但读取结果时可能需要合并多个cell的值。 

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;public class AtomicExample {public static void main(String[] args) throws InterruptedException {AtomicInteger atomicInt = new AtomicInteger(0);// 并发递增Thread t1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {atomicInt.incrementAndGet();}});Thread t2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {atomicInt.incrementAndGet();}});t1.start();t2.start();t1.join();t2.join();System.out.println("AtomicInteger result: " + atomicInt.get()); // 2000// LongAdder在高并发下性能更好LongAdder longAdder = new LongAdder();Thread t3 = new Thread(() -> {for (int i = 0; i < 1000; i++) {longAdder.increment();}});Thread t4 = new Thread(() -> {for (int i = 0; i < 1000; i++) {longAdder.increment();}});t3.start();t4.start();t3.join();t4.join();System.out.println("LongAdder result: " + longAdder.sum()); // 2000}
}

• CAS（Compare-And-Swap）机制

 CAS是一种无锁编程技术，包含三个操作数：内存位置(V)、预期原值(A)和新值(B)。当且仅当V的值等于A时，CAS才会将V的值设为B，否则不做任何操作。CAS是实现非阻塞算法的基础，但存在ABA问题（即值从A变为B又变回A，CAS无法感知中间变化）。

import java.util.concurrent.atomic.AtomicReference;public class CASExample {public static class OptimisticLock {private AtomicReference<Object> lockRef = new AtomicReference<>(new Object());public boolean tryLock() {Object current = lockRef.get();return current != null && lockRef.compareAndSet(current, null);}public void unlock() {lockRef.compareAndSet(null, new Object());}}public static void main(String[] args) {OptimisticLock lock = new OptimisticLock();if (lock.tryLock()) {try {System.out.println("Lock acquired, doing work...");} finally {lock.unlock();}} else {System.out.println("Failed to acquire lock");}}
}

•  AtomicReference与AtomicStampedReference

AtomicReference提供对对象引用的原子操作，而AtomicStampedReference通过添加版本戳解决ABA问题。AtomicStampedReference通过维护一个版本戳，可以检测到对象引用是否被修改过，即使当前值与预期值相同。

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;public class AtomicReferenceExample {public static void main(String[] args) {// AtomicReference示例AtomicReference<String> atomicRef = new AtomicReference<>("initial");boolean changed = atomicRef.compareAndSet("initial", "updated");System.out.println("Changed: " + changed + ", value: " + atomicRef.get());// AtomicStampedReference示例（解决ABA问题）AtomicStampedReference<String> stampedRef = new AtomicStampedReference<>("initial", 0);int[] stampHolder = new int[1];String current = stampedRef.get(stampHolder);System.out.println("Current value: " + current + ", stamp: " + stampHolder[0]);// 第一次更新stampedRef.compareAndSet("initial", "updated", stampHolder[0], stampHolder[0] + 1);// 模拟ABA问题stampedRef.compareAndSet("updated", "initial", 1, 2);// 使用stamp检测中间变化boolean success = stampedRef.compareAndSet("initial", "updated", 0, 1);System.out.println("With wrong stamp, update success: " + success);success = stampedRef.compareAndSet("initial", "updated", 2, 3);System.out.println("With correct stamp, update success: " + success);}
}

7.并发编程中的性能问题

7.1.上下文切换的开销

 上下文切换是多线程编程中不可避免的性能开销。当CPU从一个线程切换到另一个线程时，需要保存当前线程的状态并恢复另一个线程的状态。这种切换操作通常需要消耗1-10微秒的时间，在高并发场景下会显著影响性能。

减少上下文切换的实用技巧：

1. 合理设置线程池大小（CPU密集型任务建议N+1，IO密集型建议2N+1）
2. 使用协程（Java 19+的虚拟线程）
3. 避免不必要的线程唤醒
4. 使用无锁数据结构

// 上下文切换性能测试
public class ContextSwitchBenchmark {private static final int ITERATIONS = 1000000;private static final Object lock = new Object();private static volatile boolean flag = true;public static void main(String[] args) throws InterruptedException {// 测试线程切换开销Thread t1 = new Thread(() -> {while (flag) {synchronized (lock) {// 空循环，仅用于触发上下文切换}}});Thread t2 = new Thread(() -> {while (flag) {synchronized (lock) {// 空循环，仅用于触发上下文切换}}});long start = System.nanoTime();t1.start();t2.start();Thread.sleep(1000); // 运行1秒钟flag = false;long duration = System.nanoTime() - start;System.out.printf("Context switches per second: %,d%n", ITERATIONS * 1000000000L / duration);}
}

7.2. 锁的粒度与性能

      锁的粒度选择直接影响并发程序的性能。以下是三种常见的锁策略：

      1.粗粒度锁：简单但并发性低

// 粗粒度锁示例
public class CoarseLockExample {private final List<Integer> list = new ArrayList<>();private final Object lock = new Object();public void add(int value) {synchronized (lock) {list.add(value);}}public boolean contains(int value) {synchronized (lock) {return list.contains(value);}}
}

       2. 细粒度锁：复杂但并发性高

// 细粒度锁示例（分段锁）
public class FineGrainedLockExample {private final List<Integer>[] segments;private final Object[] locks;private static final int SEGMENT_COUNT = 16;public FineGrainedLockExample() {segments = new List[SEGMENT_COUNT];locks = new Object[SEGMENT_COUNT];for (int i = 0; i < SEGMENT_COUNT; i++) {segments[i] = new ArrayList<>();locks[i] = new Object();}}public void add(int value) {int segment = value % SEGMENT_COUNT;synchronized (locks[segment]) {segments[segment].add(value);}}public boolean contains(int value) {int segment = value % SEGMENT_COUNT;synchronized (locks[segment]) {return segments[segment].contains(value);}}
}

        3.无锁编程：最高并发性但实现复杂

// 无锁计数器示例
public class LockFreeCounter {private final AtomicInteger counter = new AtomicInteger();public void increment() {int oldValue;int newValue;do {oldValue = counter.get();newValue = oldValue + 1;} while (!counter.compareAndSet(oldValue, newValue));}public int get() {return counter.get();}
}

7.3.无锁编程与乐观锁

无锁编程通过CAS(Compare-And-Swap)操作实现线程安全，避免了传统锁带来的性能问题。

// 无锁栈实现
public class LockFreeStack<T> {private static class Node<T> {final T value;Node<T> next;Node(T value) {this.value = value;}}private AtomicReference<Node<T>> top = new AtomicReference<>();public void push(T value) {Node<T> newHead = new Node<>(value);Node<T> oldHead;do {oldHead = top.get();newHead.next = oldHead;} while (!top.compareAndSet(oldHead, newHead));}public T pop() {Node<T> oldHead;Node<T> newHead;do {oldHead = top.get();if (oldHead == null) {return null;}newHead = oldHead.next;} while (!top.compareAndSet(oldHead, newHead));return oldHead.value;}
}

8.并发编程的最佳实践

8.1. 避免过度同步

过度同步会降低程序性能并可能导致死锁。只在必要时同步，并尽量缩小同步范围。 

// 避免过度同步的示例
public class OptimizedSynchronization {private final Map<String, String> cache = new HashMap<>();private final Object lock = new Object();// 不推荐的过度同步方式public String getValueSlow(String key) {synchronized (lock) {// 模拟耗时操作try { Thread.sleep(10); } catch (InterruptedException e) {}return cache.get(key);}}// 优化后的同步方式public String getValueFast(String key) {// 先尝试无锁读取String value = cache.get(key);if (value == null) {synchronized (lock) {// 双重检查value = cache.get(key);if (value == null) {// 模拟耗时操作try { Thread.sleep(10); } catch (InterruptedException e) {}value = "generated-value";cache.put(key, value);}}}return value;}
}

8.2.使用不可变对象

不可变对象天生线程安全，可以避免同步问题。

// 不可变对象示例
public final class ImmutablePerson {private final String name;private final int age;private final List<String> hobbies;public ImmutablePerson(String name, int age, List<String> hobbies) {this.name = name;this.age = age;this.hobbies = Collections.unmodifiableList(new ArrayList<>(hobbies));}public String getName() { return name; }public int getAge() { return age; }public List<String> getHobbies() { return hobbies; }
}

8.3.合理使用线程池

正确配置线程池对系统性能至关重要。

// 线程池最佳实践
public class ThreadPoolBestPractice {public static void main(String[] args) {// 根据任务类型选择合适的线程池ExecutorService executor = new ThreadPoolExecutor(4, // 核心线程数8, // 最大线程数60, // 空闲线程存活时间TimeUnit.SECONDS,new ArrayBlockingQueue<>(100), // 有界队列防止资源耗尽new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略);// 提交任务for (int i = 0; i < 100; i++) {final int taskId = i;executor.execute(() -> {System.out.println("Executing task " + taskId + " on " + Thread.currentThread().getName());try {Thread.sleep(100); // 模拟任务执行} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}// 优雅关闭executor.shutdown();try {if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {executor.shutdownNow();}} catch (InterruptedException e) {executor.shutdownNow();Thread.currentThread().interrupt();}}
}

8.4.使用并发工具类替代手动同步

Java并发包提供了许多高级工具类，可以替代手动同步。

// 使用CountDownLatch协调多个线程
public class CountDownLatchExample {public static void main(String[] args) throws InterruptedException {int threadCount = 5;CountDownLatch startLatch = new CountDownLatch(1);CountDownLatch doneLatch = new CountDownLatch(threadCount);for (int i = 0; i < threadCount; i++) {new Thread(() -> {try {startLatch.await(); // 等待开始信号System.out.println(Thread.currentThread().getName() + " is working");Thread.sleep((long) (Math.random() * 1000));doneLatch.countDown(); // 完成工作} catch (InterruptedException e) {Thread.currentThread().interrupt();}}).start();}System.out.println("Preparing...");Thread.sleep(1000); // 模拟准备工作System.out.println("Ready, go!");startLatch.countDown(); // 发令开始doneLatch.await(); // 等待所有线程完成System.out.println("All workers completed");}
}

9.调试与测试并发程序

9.1.使用Thread.dumpStack()进行调试

// 线程堆栈调试示例
public class ThreadDebugExample {public static void main(String[] args) {new Thread(() -> {System.out.println("Thread started");Thread.dumpStack(); // 打印当前线程堆栈doWork();}).start();}private static void doWork() {System.out.println("Doing work...");// 模拟工作try { Thread.sleep(1000); } catch (InterruptedException e) {}}
}

9.2.使用jstack分析线程状态

jstack是Java虚拟机自带的线程堆栈分析工具，能够帮助开发者诊断线程死锁、阻塞、高CPU占用等问题。jstack输出的线程状态主要有以下几种

1. RUNNABLE：线程正在执行或准备执行，等待CPU调度
2. BLOCKED：线程被阻塞，等待获取监视器锁(monitor lock)
3. WAITING：无限期等待其他线程执行特定操作
4. TIMED_WAITING：有时限的等待状态
5. TERMINATED：线程已终止

以下是使用jstack分析线程状态的详细步骤和实用命令和基本使用步骤：

1. 定位Java进程ID

首先需要确定要分析的Java进程ID(PID)，可以使用以下命令：

jps -l  # 列出所有Java进程及其主类名
# 或
ps -ef | grep java  # 在Linux/Unix系统上查找Java进程

2. 查看线程CPU使用情况

使用top命令查看进程和线程的CPU使用情况：

top  # 查看所有进程的CPU使用情况
top -Hp [PID]  # 查看指定Java进程下各线程的CPU使用情况

3. 转换线程ID为16进制

jstack输出的线程ID(nid)是16进制格式，而top命令显示的是10进制，需要转换：

printf "%x\n" [十进制线程ID]  # 将top显示的线程ID转换为16进制

4. 获取线程堆栈信息

使用jstack命令获取线程堆栈：

jstack [PID] > thread_dump.txt  # 将堆栈信息输出到文件

5. 分析特定线程

在thread_dump.txt中搜索转换后的16进制线程ID(nid)，找到对应的线程堆栈信息。

例如 ：

1. 诊断CPU占用过高问题

1. 使用top找到CPU占用高的Java进程
2. 使用top -Hp [PID]找到该进程中CPU占用高的线程
3. 将线程ID转换为16进制
4. 使用jstack获取线程转储并查找对应线程
5. 分析该线程的堆栈信息，定位问题代码 

2. 诊断死锁问题

1. 使用jstack -l [PID]获取线程转储
2. 搜索输出中的"deadlock"关键词
3. 分析相互等待锁的线程链
4. 查看每个线程持有的锁和等待的锁 

死锁实例输出：

"Thread-1" prio=6 tid=0x02bcf000 nid=0xc70 waiting for monitor entry [0x02f6f000]java.lang.Thread.State: BLOCKED (on object monitor)at com.demo.DeadLock$2.run(DeadLock.java:40)- waiting to lock <0x22a297a8> (a java.lang.Object)- locked <0x22a297b0> (a java.lang.Object)"Thread-0" prio=6 tid=0x02bce400 nid=0xba0 waiting for monitor entry [0x02f1f000]java.lang.Thread.State: BLOCKED (on object monitor)at com.demo.DeadLock$1.run(DeadLock.java:25)- waiting to lock <0x22a297b0> (a java.lang.Object)- locked <0x22a297a8> (a java.lang.Object)

1. 查找状态为Blocked的线程
2. 查看waiting to lock <...>信息，确定线程在等待哪个锁
3. 查找持有该锁的线程

10.总结

     Java并发编程既强大又复杂。通过本文我们了解了：

1. 并发编程的复杂性：线程安全、竞态条件、死锁等问题

2. 如何选择合适的并发工具：

   • 基本同步：synchronized, volatile
   • 高级工具：ReentrantLock, ReadWriteLock
   • 并发集合：ConcurrentHashMap, CopyOnWriteArrayList
   • 线程池：ExecutorService, ThreadPoolExecutor
   • 原子变量：AtomicInteger, LongAdder

3. 持续学习与实践的重要性：

   • 关注Java新版本中的并发特性（如虚拟线程）
   • 学习响应式编程等新范式
   • 在实际项目中应用并发模式

// 综合示例：高性能缓存实现
public class ConcurrentCache<K, V> {private final ConcurrentHashMap<K, V> map = new ConcurrentHashMap<>();private final ConcurrentHashMap<K, FutureTask<V>> tasks = new ConcurrentHashMap<>();private final Executor executor = ForkJoinPool.commonPool();public V get(K key, Callable<V> loader) throws Exception {while (true) {FutureTask<V> task = tasks.get(key);if (task != null) {try {return task.get();} catch (ExecutionException e) {tasks.remove(key, task);throw (Exception) e.getCause();} catch (CancellationException e) {tasks.remove(key, task);}}FutureTask<V> newTask = new FutureTask<>(loader);task = tasks.putIfAbsent(key, newTask);if (task == null) {task = newTask;executor.execute(task);}}}
}

       并发编程是一门需要不断实践和学习的艺术。从简单的锁开始，逐步掌握更高级的并发工具和模式，最终写出既正确又高效的并发代码。文章写的仓促，排版格式不好请大家见谅，感谢大家查阅！