一、多线程基础概念

1. 进程 vs 线程

• 进程：操作系统资源分配的最小单位（独立内存空间）。
• 线程：CPU 调度的最小单位（共享进程内存），轻量级并发执行单元。

2. 线程的创建方式

• 继承 Thread 类

class MyThread extends Thread { 
  	@Override 
  	public void run() { 
      	System.out.println("Thread running: " + Thread.currentThread().getName()); 
    }
} 
// 启动 
new MyThread().start();

• 实现 Runnable 接口（推荐，避免单继承限制）

Runnable task = () -> System.out.println("Runnable running: " + Thread.currentThread().getName()); 
new Thread(task).start();

• 实现 Callable 接口（支持返回值）

class MyCallable implements Callable<Integer> { 
  	@Override public Integer call() throws Exception { return 42; }
}
// 使用 FutureTask 获取结果 
FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable()); 
new Thread(futureTask).start(); 
System.out.println("Result: " + futureTask.get()); // 阻塞获取结果

二、线程生命周期与核心操作

1. 线程状态

• NEW：线程对象已创建，未调用 start()。
• RUNNABLE：可运行状态（可能正在执行或等待 CPU 时间片）。
• BLOCKED：等待获取锁时阻塞。
• WAITING：无限期等待（wait(), join()）。
• TIMED_WAITING：有限等待（sleep(ms), wait(timeout)）。
• TERMINATED：线程执行完毕。

2. 常用方法

• start()：启动线程。
• sleep(long ms)：当前线程休眠指定毫秒（不释放锁）。
• join()：等待线程终止（常用于主线程等待子线程）。
• interrupt()：中断线程（需配合逻辑处理）。
• yield()：提示调度器让出 CPU（不保证生效）。

三、线程同步与线程安全

1. 同步机制

• synchronized 关键字

// 同步代码块（锁对象）
synchronized (lockObject) {
  	// 临界区代码 
}
// 同步方法（锁 this 或 Class 对象） 
public synchronized void safeMethod() { ... } 

// 静态同步方法（锁 Class 对象） 
public static synchronized void staticSafeMethod() { ... }

• ReentrantLock（更灵活的可重入锁）

private final ReentrantLock lock = new ReentrantLock(); 
public void performTask() { 
		lock.lock(); 
    try { 
      // 临界区代码 
    } finally { 
      	lock.unlock(); // 必须手动释放 
    } 
}

2. 线程安全工具类

• Atomic 原子类（无锁线程安全操作）

AtomicInteger counter = new AtomicInteger(0); 
counter.incrementAndGet(); // 原子自增

• 并发集合（替代传统集合）

List<String> safeList = new CopyOnWriteArrayList<>(); 
Map<String, Integer> safeMap = new ConcurrentHashMap<>();

四、线程池与性能优化

1. Executor 框架（推荐替代手动创建线程）

• 核心接口：Executor, ExecutorService, ScheduledExecutorService
• 内置线程池：

// 固定线程数（适合稳定负载） 
ExecutorService fixedPool = Executors.newFixedThreadPool(4); 
// 缓存线程池（适合短时异步任务） 
ExecutorService cachedPool = Executors.newCachedThreadPool(); 
// 单线程池（保证任务顺序执行） 
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor(); 
// 调度线程池（定时任务） 
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(2); 
scheduledPool.scheduleAtFixedRate(task, initialDelay, period, TimeUnit.SECONDS);

2. 自定义线程池（ThreadPoolExecutor）

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    4, // 核心线程数
    10, // 最大线程数
    60, // 空闲线程存活时间
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100), // 任务队列
    new ThreadFactory() { ... }, // 自定义线程创建逻辑
    new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
);

五、高级并发工具类（JUC）

1. CountDownLatch（等待多个任务完成）

CountDownLatch latch = new CountDownLatch(3);
executor.submit(() -> {
    // 执行任务
    latch.countDown();
});
latch.await(); // 阻塞直到计数器归零

2. CyclicBarrier（多线程相互等待）

CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("所有线程到达屏障"));
executor.submit(() -> {
    // 执行任务
    barrier.await(); // 等待其他线程
});

3. Semaphore（控制并发资源访问数）

Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问
semaphore.acquire(); // 获取许可
try {
    // 使用资源
} finally {
    semaphore.release(); // 释放许可
}

六、常见问题与最佳实践

1. 避免死锁

• 按固定顺序获取锁。
• 使用 tryLock() 设置超时。

2. 处理线程中断

while (!Thread.currentThread().isInterrupted()) {
    try {
        // 执行任务
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // 重置中断状态
        break;
    }
}

3. 内存可见性问题

• 使用 volatile 关键字保证变量可见性。
• 优先使用 Atomic 类或 synchronized 块。

总结

Java 多线程是构建高性能应用的核心技术，关键点包括：

1. 线程创建与生命周期管理
2. 同步机制与线程安全（synchronized、Lock、Atomic）
3. 线程池优化资源使用（Executor框架、自定义线程池）
4. 高级并发工具类（CountDownLatch、CyclicBarrier）

深入学习方向：

• CompletableFuture（Java 8+ 异步编程）
• Fork/Join 框架（分治任务处理）
• Reactive 编程（如 Project Reactor）