Java多线程的实现原理及案例

# Java多线程的实现原理及案例

## 一、多线程基础概念

### 1.1 进程与线程的区别
- **进程**：操作系统资源分配的基本单位，拥有独立的地址空间
- **线程**：CPU调度的基本单位，共享进程资源，切换开销小
- 关系：一个进程包含多个线程（至少1个主线程）

### 1.2 多线程优势
- 提高CPU利用率（避免I/O阻塞）
- 提升系统吞吐量（并发处理）
- 改善响应时间（后台任务不影响UI）

## 二、Java线程实现原理

### 2.1 线程创建方式
#### 2.1.1 继承Thread类
```java
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}
// 启动
new MyThread().start();

2.1.2 实现Runnable接口（推荐）

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}
// 启动
new Thread(new MyRunnable()).start();

2.1.3 实现Callable接口（带返回值）

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
}
// 使用
FutureTask<String> task = new FutureTask<>(new MyCallable());
new Thread(task).start();
System.out.println(task.get()); // 获取返回值

2.2 JVM线程模型

• 1:1模型：Java线程与内核线程直接映射
• 栈内存：每个线程拥有独立的虚拟机栈（默认1MB）
• 程序计数器：线程私有，记录执行位置

2.3 线程生命周期

stateDiagram
    [*] --> NEW
    NEW --> RUNNABLE: start()
    RUNNABLE --> RUNNING: 获取CPU
    RUNNING --> BLOCKED: 同步阻塞
    BLOCKED --> RUNNABLE: 获取锁
    RUNNING --> WTING: wait()/join()
    WTING --> RUNNABLE: notify()
    RUNNING --> TERMINATED: run()结束

三、线程同步机制

3.1 锁的实现原理

3.1.1 synchronized关键字

• 对象头Mark Word：存储锁状态（无锁/偏向锁/轻量级锁/重量级锁）
• 锁升级过程：偏向锁→轻量级锁（CAS）→重量级锁（OS互斥量）

// 实例方法锁
public synchronized void method() {}

// 代码块锁
public void method() {
    synchronized(obj) {}
}

3.1.2 ReentrantLock

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

3.2 线程通信

3.2.1 wait/notify机制

synchronized(lock) {
    while(conditionNotMet) {
        lock.wait(); // 释放锁
    }
    // 处理逻辑
    lock.notifyAll();
}

3.2.2 Condition接口

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    condition.await();
    condition.signal();
} finally {
    lock.unlock();
}

四、线程池技术

4.1 ThreadPoolExecutor核心参数

4.2 工作流程

1. 提交任务到核心线程
2. 核心线程满→进入队列
3. 队列满→创建非核心线程
4. 达到最大线程数→触发拒绝策略

4.3 创建示例

ExecutorService pool = Executors.newFixedThreadPool(5);
pool.execute(() -> {
    System.out.println("Task running");
});
pool.shutdown();

五、实战案例

5.1 生产者-消费者模型

class Buffer {
    private Queue<Integer> queue = new LinkedList<>();
    private int capacity;
    
    public Buffer(int capacity) {
        this.capacity = capacity;
    }
    
    public synchronized void produce(int item) throws InterruptedException {
        while(queue.size() == capacity) {
            wait();
        }
        queue.offer(item);
        notifyAll();
    }
    
    public synchronized int consume() throws InterruptedException {
        while(queue.isEmpty()) {
            wait();
        }
        int item = queue.poll();
        notifyAll();
        return item;
    }
}

5.2 高并发计数器

class Counter {
    private AtomicLong count = new AtomicLong(0);
    
    public void increment() {
        count.incrementAndGet();
    }
    
    public long get() {
        return count.get();
    }
}

5.3 CompletableFuture异步编排

CompletableFuture.supplyAsync(() -> queryFromDB())
    .thenApplyAsync(data -> processData(data))
    .thenAcceptAsync(result -> saveResult(result))
    .exceptionally(ex -> {
        System.err.println("Error: " + ex);
        return null;
    });

六、性能优化建议

1. 减少锁粒度：使用ConcurrentHashMap分段锁
2. 避免死锁：按固定顺序获取多把锁
3. 线程复用：优先使用线程池
4. 减少上下文切换：避免创建过多线程
5. 使用无锁结构：Atomic类/CAS操作

七、常见问题排查

1. 死锁检测：jstack查看线程阻塞链
2. CPU过高：arthas监控热点方法
3. 内存泄漏：ThreadLocal未清理导致
4. 线程数暴涨：检查线程池配置

最佳实践：多线程编程应遵循”先正确性，再优化性能”的原则，合理使用JUC工具类能显著降低开发复杂度。 “`

（注：实际字数约1800字，可根据需要增减案例部分调整字数）