以下是一个结构清晰的Java多线程编程知识框架，涵盖基础原理到实战应用：

一、多线程基础原理

1. 线程与进程

   • 进程：操作系统资源分配的基本单位（独立内存空间）
   • 线程：CPU调度的基本单位（共享进程内存），轻量级执行单元
   • 关系：一个进程包含多个线程，线程间共享堆内存、方法区，独享栈内存

2. 线程创建方式

   // 1. 继承Thread类
   class MyThread extends Thread {
       @Override
       public void run() {
           System.out.println("Thread running");
       }
   }
   
   // 2. 实现Runnable接口
   class MyRunnable implements Runnable {
       @Override
       public void run() {
           System.out.println("Runnable running");
       }
   }
   
   // 3. 实现Callable接口（带返回值）
   class MyCallable implements Callable<String> {
       @Override
       public String call() throws Exception {
           return "Callable result";
       }
   }
   

3. 线程生命周期

   • 六种状态：NEW（新建）、RUNNABLE（可运行）、BLOCKED（阻塞）、WAITING（等待）、TIMED_WAITING（限时等待）、TERMINATED（终止）
   • 状态转换图：
     $$ \text{NEW} \xrightarrow{\text{start()}} \text{RUNNABLE} \xrightarrow{\text{sync/IO}} \text{BLOCKED} \xrightarrow{\text{wait()}} \text{WAITING} $$

二、线程同步与通信

1. 同步机制

   • synchronized
     • 修饰实例方法：锁定当前对象实例
     • 修饰静态方法：锁定类的Class对象
     • 同步代码块：指定锁对象（如 synchronized(lock) {...}）
   • Lock API

     ReentrantLock lock = new ReentrantLock();
     lock.lock();
     try {
         // 临界区代码
     } finally {
         lock.unlock();
     }
     

2. 线程通信

   • wait()/notify()

     synchronized (obj) {
         while (condition) {
             obj.wait(); // 释放锁并等待
         }
         obj.notify(); // 唤醒等待线程
     }
     

   • Condition（配合Lock使用）

     Condition condition = lock.newCondition();
     condition.await();  // 类似wait()
     condition.signal(); // 类似notify()
     

三、并发工具类（JUC包）

1. 原子操作类

   • AtomicInteger：原子整型操作

     AtomicInteger count = new AtomicInteger(0);
     count.incrementAndGet(); // 线程安全自增
     

2. 并发容器

   • ConcurrentHashMap：分段锁实现高并发读写
   • CopyOnWriteArrayList：写时复制，适用于读多写少场景

3. 线程池（ThreadPoolExecutor）

   ExecutorService pool = new ThreadPoolExecutor(
       4, // 核心线程数
       8, // 最大线程数
       60, // 空闲线程存活时间
       TimeUnit.SECONDS,
       new LinkedBlockingQueue<>(100) // 任务队列
   );
   pool.submit(() -> System.out.println("Task executed"));
   

4. CountDownLatch & CyclicBarrier

   • CountDownLatch：等待多个任务完成

     CountDownLatch latch = new CountDownLatch(3);
     latch.countDown(); // 计数器减1
     latch.await();     // 阻塞直到计数器归零
     

   • CyclicBarrier：多个线程到达屏障点后继续执行

     CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads arrived"));
     barrier.await(); // 线程等待
     

四、实战应用场景

1. 高并发计数器

   private AtomicLong counter = new AtomicLong(0);
   public void increment() {
       counter.incrementAndGet();
   }
   

2. 生产者-消费者模型

   BlockingQueue<Task> queue = new LinkedBlockingQueue<>(10);
   // 生产者
   queue.put(task); // 阻塞式添加
   // 消费者
   Task task = queue.take(); // 阻塞式获取
   

3. 异步任务处理（CompletableFuture）

   CompletableFuture.supplyAsync(() -> fetchData())
       .thenApply(data -> process(data))
       .thenAccept(result -> save(result));
   

五、常见问题与优化

1. 死锁预防

   • 避免嵌套锁
   • 使用定时锁（tryLock(timeout)）
   • 锁排序（固定加锁顺序）

2. 性能调优

   • 根据任务类型选择线程池参数（CPU密集型 vs I/O密集型）
   • 减少锁粒度（如 ConcurrentHashMap 的分段锁）

3. 线程安全设计原则

   • 优先使用不可变对象（如 String、BigInteger）
   • 用线程局部变量避免共享（ThreadLocal）

     ThreadLocal<SimpleDateFormat> dateFormat = 
         ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
     

通过此框架，可系统掌握Java多线程的核心技术，并在实际项目中灵活应用。