Java并发编程基础：环境搭建与核心概念解析

1. Java并发编程基础与环境搭建

1.1 开发环境准备

在开始Java并发编程之前，我们需要配置好开发环境。以下是Maven项目的基本配置：

xml复制<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
</properties>

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.9</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.25</version>
    </dependency>
</dependencies>

这个配置指定了Java 8的编译环境，并引入了Lombok（简化代码）和Logback（日志记录）依赖。选择Java 8是因为它提供了相对成熟的并发API，同时保持较好的兼容性。

1.2 日志配置优化

并发编程中，良好的日志记录至关重要。以下是推荐的logback.xml配置：

xml复制<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <property name="LOG_HOME" value="/home" />
    
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>${LOG_HOME}/TestWeb.log.%d{yyyy-MM-dd}.log</FileNamePattern>
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>
    
    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

这个配置的关键点：

1. 控制台和文件双输出
2. 文件按天分割，保留30天
3. 单个日志文件最大10MB
4. 日志格式包含线程名，这对并发调试非常重要

注意：生产环境中建议将日志级别调整为DEBUG或TRACE时谨慎，可能产生大量日志影响性能。

2. 并发编程核心概念

2.1 进程与线程的本质区别

进程和线程是操作系统的基本概念，但在Java并发编程中需要深入理解它们的差异：

1. 资源分配：

   • 进程是资源分配的最小单位，每个进程有独立的内存空间
   • 线程共享进程资源，但有自己的栈和程序计数器

2. 执行模型：

   • 一个程序至少有一个进程
   • 一个进程至少有一个线程（主线程）
   • 线程是CPU调度的基本单位

3. 通信成本：

   • 进程间通信(IPC)需要特殊机制（管道、共享内存等）
   • 线程可以直接读写进程内存，但需要同步机制

java复制// 线程共享内存示例
public class SharedMemoryDemo {
    static int sharedCount = 0;
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                sharedCount++;
            }
        });
        
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                sharedCount++;
            }
        });
        
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        
        System.out.println("Final count: " + sharedCount); // 通常不是2000
    }
}

这个例子展示了线程共享变量导致的数据竞争问题，实际输出通常小于2000，因为++操作不是原子的。

2.2 并发与并行的精确理解

并发和并行经常被混淆，但它们有本质区别：

1. 并发(Concurrency)：

   • 逻辑上的同时发生
   • 单核CPU通过时间片轮转实现
   • 重点是任务分解和响应性

2. 并行(Parallelism)：

   • 物理上的同时执行
   • 需要多核CPU支持
   • 重点是性能提升

java复制// 并发示例：单核上的时间片轮转
public class ConcurrencyDemo {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Task 1")).start();
        new Thread(() -> System.out.println("Task 2")).start();
    }
}

// 并行示例：多核上的真正同时执行
public class ParallelismDemo {
    public static void main(String[] args) {
        IntStream.range(0, 10)
            .parallel()
            .forEach(i -> System.out.println(Thread.currentThread().getName()));
    }
}

实际开发中，我们通常使用线程池来管理并发任务，合理设置线程数：

• CPU密集型：线程数 ≈ CPU核心数
• IO密集型：线程数可以更多（具体取决于IO等待时间）

3. Java线程创建与管理

3.1 线程创建的三种标准方式

方式一：继承Thread类

java复制public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running: " + getName());
    }
    
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 正确启动方式
        // thread.run(); // 错误！这会在主线程执行
    }
}

缺点：Java是单继承，这种方式限制了类的扩展性。

方式二：实现Runnable接口（推荐）

java复制public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running: " 
            + Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

优点：

1. 避免单继承限制
2. 任务与线程分离
3. 更适合线程池等高级用法

Java 8后可以用lambda简化：

java复制new Thread(() -> System.out.println("Lambda running")).start();

方式三：FutureTask + Callable

java复制public class CallableDemo {
    public static void main(String[] args) throws Exception {
        FutureTask<Integer> task = new FutureTask<>(() -> {
            Thread.sleep(1000);
            return 42;
        });
        
        new Thread(task).start();
        
        System.out.println("Result: " + task.get()); // 阻塞直到获取结果
    }
}

特点：

1. 可以获取返回值
2. 可以抛出异常
3. 适合需要结果的异步计算

3.2 线程生命周期与状态转换

Java线程有6种状态（Thread.State）：

1. NEW：创建但未start()
2. RUNNABLE：可运行或正在运行
3. BLOCKED：等待监视器锁（synchronized）
4. WAITING：无限期等待（Object.wait()等）
5. TIMED_WAITING：限期等待（Thread.sleep()等）
6. TERMINATED：执行结束

java复制public class ThreadStateDemo {
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000);
                synchronized (ThreadStateDemo.class) {
                    ThreadStateDemo.class.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        System.out.println(t.getState()); // NEW
        
        t.start();
        System.out.println(t.getState()); // RUNNABLE
        
        Thread.sleep(500);
        System.out.println(t.getState()); // TIMED_WAITING
        
        Thread.sleep(1000);
        System.out.println(t.getState()); // BLOCKED (等待锁)
        
        synchronized (ThreadStateDemo.class) {
            ThreadStateDemo.class.notify();
            System.out.println(t.getState()); // WAITING
        }
        
        t.join();
        System.out.println(t.getState()); // TERMINATED
    }
}

理解这些状态对调试多线程问题非常重要，可以用jstack工具查看线程状态。

3.3 线程常用API详解

join()方法：线程同步

java复制public class JoinDemo {
    static int result = 0;
    
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000);
                result = 42;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        t.start();
        t.join(); // 主线程等待t完成
        System.out.println(result); // 保证输出42
    }
}

注意事项：

1. join()可以设置超时时间
2. 多个join()的顺序会影响总等待时间
3. 不要在主线程中join()自己（死锁）

interrupt()方法：线程中断

Java没有真正的线程终止方法，interrupt()是协作式的中断机制：

java复制public class InterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Running...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Interrupted during sleep");
                    Thread.currentThread().interrupt(); // 重置中断状态
                }
            }
            System.out.println("Thread exiting");
        });
        
        t.start();
        Thread.sleep(3500);
        t.interrupt();
    }
}

关键点：

1. sleep()/wait()等方法会响应中断并清除中断状态
2. 需要正确处理InterruptedException
3. 对于阻塞IO，可能需要关闭底层资源来中断

守护线程(Daemon)

java复制public class DaemonDemo {
    public static void main(String[] args) {
        Thread daemon = new Thread(() -> {
            while (true) {
                System.out.println("Daemon working...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        daemon.setDaemon(true);
        daemon.start();
        
        System.out.println("Main thread exiting");
    }
}

特点：

1. 所有非守护线程结束时，JVM会退出
2. 守护线程的finally块不一定执行
3. 适合执行辅助任务（如GC）

4. 线程安全与同步机制

4.1 线程安全问题本质

线程安全问题的根源在于共享数据的非原子操作：

java复制public class UnsafeCounter {
    private int count = 0;
    
    public void increment() {
        count++; // 非原子操作
    }
    
    public int getCount() {
        return count;
    }
}

count++实际上包含三个操作：

1. 读取count值
2. 计算count+1
3. 写入新值

4.2 synchronized关键字

最基本的同步机制：

java复制public class SafeCounter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

原理：

1. 方法级锁：锁对象是this
2. 代码块锁：可以指定锁对象
3. 静态方法锁：锁的是Class对象

java复制public class SyncBlockDemo {
    private final Object lock = new Object();
    private int count = 0;
    
    public void increment() {
        synchronized (lock) { // 比方法级锁更灵活
            count++;
        }
    }
}

4.3 volatile关键字

保证可见性和有序性，但不保证原子性：

java复制public class VolatileDemo {
    private volatile boolean flag = false;
    
    public void writer() {
        flag = true; // 写操作
    }
    
    public void reader() {
        if (flag) { // 读操作
            System.out.println("Flag is true");
        }
    }
}

适用场景：

1. 状态标志位
2. 单例模式的双重检查锁定
3. 读多写少的简单计数器

4.4 原子类

java.util.concurrent.atomic包提供了原子操作类：

java复制public class AtomicDemo {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // 原子操作
    }
    
    public int getCount() {
        return count.get();
    }
}

实现原理：

1. CAS (Compare-And-Swap) 操作
2. 底层CPU指令支持
3. 无锁算法，性能通常比锁高

5. 线程池最佳实践

5.1 为什么需要线程池

线程创建和销毁的开销很大，线程池可以：

1. 重用已有线程
2. 控制并发数量
3. 提供任务队列
4. 提供拒绝策略

5.2 ThreadPoolExecutor详解

java复制public class ThreadPoolDemo {
    public static void main(String[] args) {
        int corePoolSize = 5;
        int maxPoolSize = 10;
        long keepAliveTime = 60L;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);
        
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            corePoolSize,
            maxPoolSize,
            keepAliveTime,
            TimeUnit.SECONDS,
            workQueue,
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
        
        for (int i = 0; i < 50; i++) {
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " executing");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        
        executor.shutdown();
    }
}

关键参数：

1. corePoolSize：核心线程数
2. maxPoolSize：最大线程数
3. keepAliveTime：非核心线程空闲存活时间
4. workQueue：任务队列
5. handler：拒绝策略

5.3 Executors工厂类

提供了几种常用线程池：

1. newFixedThreadPool：固定大小线程池
2. newCachedThreadPool：可缓存线程池
3. newSingleThreadExecutor：单线程池
4. newScheduledThreadPool：定时任务线程池

注意：阿里巴巴Java规范不建议直接使用Executors创建线程池，因为默认参数可能导致OOM。

6. 并发工具类

6.1 CountDownLatch

允许一个或多个线程等待其他线程完成：

java复制public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        for (int i = 0; i < 3; i++) {
            executor.execute(() -> {
                System.out.println("Task started");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task completed");
                latch.countDown();
            });
        }
        
        latch.await();
        System.out.println("All tasks completed");
        executor.shutdown();
    }
}

6.2 CyclicBarrier

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

java复制public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("All threads reached barrier");
        });
        
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println("Thread waiting at barrier");
                try {
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("Thread continued");
            }).start();
        }
    }
}

6.3 Semaphore

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

java复制public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问
        
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " acquired permit");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName() + " released permit");
                }
            }).start();
        }
    }
}

7. 并发编程实战技巧

7.1 避免死锁的四个条件

1. 互斥条件：资源一次只能被一个线程占用
2. 占有且等待：线程持有资源并等待其他资源
3. 不可抢占：资源只能由持有线程释放
4. 循环等待：多个线程形成等待环

解决方法：

1. 按固定顺序获取锁
2. 使用tryLock()设置超时
3. 减少锁的粒度
4. 使用更高级的并发工具

7.2 性能优化建议

1. 减小锁的范围
2. 降低锁的粒度
3. 使用读写锁（ReentrantReadWriteLock）
4. 考虑无锁数据结构（如ConcurrentHashMap）
5. 合理设置线程池参数

7.3 调试多线程程序

1. 使用Thread.dumpStack()打印堆栈
2. jstack工具分析线程状态
3. 使用IDE的调试器暂停所有线程
4. 添加详细的日志（包含线程名）
5. 使用CountDownLatch等工具控制执行顺序

8. Java内存模型(JMM)与happens-before

8.1 JMM基本概念

Java内存模型定义了：

1. 变量的可见性规则
2. 操作的执行顺序
3. 线程间的交互方式

8.2 happens-before原则

重要的happens-before规则：

1. 程序顺序规则
2. 锁规则
3. volatile变量规则
4. 线程启动规则
5. 线程终止规则
6. 中断规则
7. 终结器规则
8. 传递性

java复制public class HappensBeforeDemo {
    int x = 0;
    volatile boolean v = false;
    
    public void writer() {
        x = 42;  // 1
        v = true; // 2
    }
    
    public void reader() {
        if (v) { // 3
            System.out.println(x); // 4
        }
    }
}

由于volatile的happens-before规则，如果reader看到v=true，那么一定能看到x=42。

8.3 final字段的特殊规则

正确构造的不可变对象是线程安全的：

java复制public class FinalFieldDemo {
    final int x;
    
    public FinalFieldDemo() {
        x = 42; // 正确构造
    }
    
    public void print() {
        System.out.println(x); // 保证看到正确初始化的值
    }
}

9. 常见并发问题模式

9.1 竞态条件(Race Condition)

java复制public class RaceCondition {
    private int count = 0;
    
    public void increment() {
        if (count < 10) { // 竞态条件
            count++;
        }
    }
}

解决方法：将检查和操作作为一个原子操作

9.2 死锁(Deadlock)

java复制public class DeadlockDemo {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something
            }
        }
    }
    
    public void method2() {
        synchronized (lock2) {
            synchronized (lock1) {
                // do something
            }
        }
    }
}

解决方法：按固定顺序获取锁

9.3 活锁(Livelock)

java复制public class LivelockDemo {
    static class Person {
        boolean isMovingRight = true;
        
        void meet(Person other) {
            while (other.isMovingRight == this.isMovingRight) {
                // 两人互相让路但总是同方向
                isMovingRight = !isMovingRight;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        
        new Thread(() -> p1.meet(p2)).start();
        new Thread(() -> p2.meet(p1)).start();
    }
}

解决方法：引入随机性或其他协调机制

10. Java并发集合类

10.1 ConcurrentHashMap

java复制public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        
        // 线程安全的putIfAbsent
        map.putIfAbsent("key", 1);
        
        // 原子更新
        map.compute("key", (k, v) -> v == null ? 1 : v + 1);
        
        // 并行操作
        map.forEach(2, (k, v) -> 
            System.out.println(k + "=" + v + " by " + Thread.currentThread().getName()));
    }
}

10.2 CopyOnWriteArrayList

java复制public class CopyOnWriteDemo {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        
        list.add("item1");
        list.add("item2");
        
        // 迭代过程中可以安全修改
        for (String item : list) {
            System.out.println(item);
            list.add("newItem");
        }
        
        System.out.println("Final list: " + list);
    }
}

适用场景：读多写少，迭代操作频繁

10.3 BlockingQueue

java复制public class BlockingQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        
        // 生产者
        new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        // 消费者
        new Thread(() -> {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

11. CompletableFuture异步编程

11.1 基本用法

java复制public class CompletableFutureDemo {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Calculating...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        }).thenApply(result -> result * 2)
          .thenAccept(result -> 
              System.out.println("Final result: " + result));
        
        System.out.println("Main thread continues...");
        try {
            Thread.sleep(2000); // 等待异步任务完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

11.2 组合多个Future

java复制public class CompletableFutureCombine {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> future1 = CompletableFuture
            .supplyAsync(() -> 10);
        
        CompletableFuture<Integer> future2 = CompletableFuture
            .supplyAsync(() -> 20);
        
        CompletableFuture<Integer> combined = future1
            .thenCombine(future2, (a, b) -> a + b);
        
        System.out.println("Combined result: " + combined.get());
    }
}

11.3 异常处理

java复制public class CompletableFutureException {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            if (Math.random() > 0.5) {
                throw new RuntimeException("Error occurred");
            }
            return "Success";
        }).exceptionally(ex -> {
            System.out.println("Exception: " + ex.getMessage());
            return "Recovered";
        }).thenAccept(System.out::println);
    }
}

12. 实战：高性能计数器

12.1 简单实现（线程不安全）

java复制public class SimpleCounter {
    private int count = 0;
    
    public void increment() {
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

12.2 同步实现（线程安全但性能低）

java复制public class SynchronizedCounter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

12.3 原子类实现（高性能线程安全）

java复制public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();
    }
    
    public int getCount() {
        return count.get();
    }
}

12.4 LongAdder实现（超高并发场景）

java复制public class LongAdderCounter {
    private LongAdder count = new LongAdder();
    
    public void increment() {
        count.increment();
    }
    
    public long getCount() {
        return count.sum();
    }
}

性能比较：

• 低并发：AtomicInteger最快
• 高并发：LongAdder最优
• 同步版本性能最差

13. 实战：生产者-消费者模式

13.1 使用BlockingQueue实现

java复制public class ProducerConsumer {
    private static class Producer implements Runnable {
        private BlockingQueue<Integer> queue;
        
        public Producer(BlockingQueue<Integer> queue) {
            this.queue = queue;
        }
        
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    private static class Consumer implements Runnable {
        private BlockingQueue<Integer> queue;
        
        public Consumer(BlockingQueue<Integer> queue) {
            this.queue = queue;
        }
        
        @Override
        public void run() {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
        new Thread(new Producer(queue)).start();
        new Thread(new Consumer(queue)).start();
    }
}

13.2 使用wait/notify实现

java复制public class ProducerConsumerWaitNotify {
    private static List<Integer> buffer = new ArrayList<>();
    private static final int MAX_SIZE = 5;
    
    private static class Producer implements Runnable {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (buffer) {
                        while (buffer.size() == MAX_SIZE) {
                            buffer.wait();
                        }
                        buffer.add(i);
                        System.out.println("Produced: " + i);
                        buffer.notifyAll();
                    }
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    private static class Consumer implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    synchronized (buffer) {
                        while (buffer.isEmpty()) {
                            buffer.wait();
                        }
                        int item = buffer.remove(0);
                        System.out.println("Consumed: " + item);
                        buffer.notifyAll();
                    }
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
    }
}

14. 实战：缓存实现

14.1 简单缓存（非线程安全）

java复制public class SimpleCache<K, V> {
    private final Map<K, V> cache = new HashMap<>();
    
    public V get(K key) {
        return cache.get(key);
    }
    
    public void put(K key, V value) {
        cache.put(key, value);
    }
}

14.2 同步缓存（线程安全）

java复制public class SynchronizedCache<K, V> {
    private final Map<K, V> cache = new HashMap<>();
    
    public synchronized V get(K key) {
        return cache.get(key);
    }
    
    public synchronized void put(K key, V value) {
        cache.put(key, value);
    }
}

14.3 并发缓存（高性能）

java复制public class ConcurrentCache<K, V> {
    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();
    
    public V get(K key) {
        return cache.get(key);
    }
    
    public void put(K key, V value) {
        cache.put(key, value);
    }
    
    public V computeIfAbsent(K key, Function<K, V> mappingFunction) {
        return cache.computeIfAbsent(key, mappingFunction);
    }
}

14.4 带过期时间的缓存

java复制public class ExpiringCache<K, V> {
    private final ConcurrentHashMap<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService cleaner = Executors.newScheduledThreadPool(1);
    
    private static class CacheEntry<V> {
        final V value;
        final long expiryTime;
        
        CacheEntry(V value, long ttl) {
            this.value = value;
            this.expiryTime = System.currentTimeMillis() + ttl;
        }
        
        boolean isExpired() {
            return System.currentTimeMillis() > expiryTime;
        }
    }
    
    public ExpiringCache() {
        cleaner.scheduleAtFixedRate(this::cleanup, 1, 1, TimeUnit.SECONDS);
    }
    
    public void put(K key, V value, long ttl) {
        cache.put(key, new CacheEntry<>(value, ttl));
    }
    
    public V get(K key) {
        CacheEntry<V> entry = cache.get(key);
        if (entry == null || entry.isExpired()) {
            return null;
        }
        return entry.value;
    }
    
    private void cleanup() {
        cache.entrySet().removeIf(entry -> entry.getValue().isExpired());
    }
    
    public void shutdown() {
        cleaner.shutdown();
    }
}

15. Java并发编程最佳实践

1. 优先使用高级并发工具：

   • 使用ExecutorService而不是直接创建Thread
   • 使用ConcurrentHashMap而不是同步的HashMap
   • 使用Atomic变量而不是同步代码块

2. 避免过早优化：

   • 先保证正确性，再考虑性能
   • 使用简单的同步机制，除非性能测试表明需要更复杂的方案

3. 注意资源清理：

   • 关闭线程池
   • 释放锁和资源
   • 处理InterruptedException

4. 测试并发代码：

   • 使用压力测试
   • 使用专门的并发测试工具（如JCStress）
   • 在不同硬件上测试

5. 文档化线程安全保证：

   • 明确类的线程安全级别
   • 记录需要的同步外部调用
   • 说明不变式和后置条件

6. 避免常见陷阱：

   • 不要依赖线程优先级
   • 不要忽略InterruptedException
   • 不要过度同步
   • 注意死锁条件

7. 监控和调试：

   • 使用JMX监控线程状态
   • 使用jstack分析线程转储
   • 添加适当的日志记录

16. Java并发编程的未来

16.1 虚拟线程（Project Loom）

Java 19引入的虚拟线程（轻量级线程）将改变并发编程方式：

java复制// 预览功能，Java 19+
public class VirtualThreadDemo {
    public static void main(String[] args) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10_000; i++) {
                executor.submit(() -> {
                    Thread.sleep(1000);
                    System.out.println("Task completed");
                    return null;
                });
            }
        }
    }
}

特点：

1. 轻量级（非OS线程）
2. 高吞吐量（可创建数百万个）
3. 兼容现有代码

16.2 结构化并发（Structured Concurrency）

java复制// 预览功能，Java 19+
public class StructuredConcurrencyDemo {
    public static void main(String[] args) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Future<Integer> future1 = scope.fork(() -> task1());
            Future<String> future2 = scope.fork(() -> task2());
            
            scope.join();
            scope.throwIfFailed();
            
            System.out.println(future1.resultNow() + future2.resultNow());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    static int task1() throws InterruptedException {
        Thread.sleep(1000);
        return 42;
    }
    
    static String task2() throws InterruptedException {
        Thread.sleep(1500);
        return "Hello";
    }
}

优点：

1. 更好的错误处理
2. 更清晰的代码结构
3. 自动资源管理

16.3 其他发展趋势

1. 更强大的异步编程支持
2. 更好的与反应式编程集成
3. 硬件特性的更好利用（如向量指令）
4. 更智能的运行时优化

17. 性能调优实战

17.1 锁竞争分析

使用JFR（Java Flight Recorder）分析锁竞争：

bash复制java -XX:+UnlockCommercialFeatures -XX:+FlightRecorder \
-XX:StartFlightRecording=duration=60s,filename=recording.jfr \
YourApplication

然后使用JD