“为什么你的多线程代码总是Bug频出？面试一问高并发就懵？”
本文用 20个真实场景案例 + 6个可运行Demo，带你从线程底层原理直捣高并发实战，彻底告别线程安全、死锁、性能瓶颈！
（文末送《Java并发编程核心笔记》，先赞后看，养成习惯）

一、为什么多线程是Java程序员的分水岭？

• 数据说话：BAT大厂招聘中，90%的Java岗位要求精通多线程与高并发设计
• 薪资差距：掌握并发编程的程序员平均薪资高出30%（数据来源：拉勾网）
• 高频面试题：线程状态切换、synchronized与Lock区别、CAS原理、线程池参数

二、多线程底层原理（图解）

1. 线程 vs 进程

java

// 进程：独立的JVM实例  
// 线程：进程内的执行单元，共享堆内存，独立栈内存

2. Java内存模型（JMM）

• 可见性问题：volatile关键字如何解决？（MESI协议）
• 原子性问题：i++为何不安全？（非原子操作拆分为3步）
• 有序性问题：指令重排序与happens-before原则

3. 线程生命周期

复制

新建(New) → 就绪(Runnable) → 运行(Running) → 阻塞(Blocked) → 死亡(Terminated)  

• 关键方法：start()、run()、sleep()、wait()、notify()、join()

三、手写6个Demo，彻底掌握核心API

Demo1：三种创建线程的方式

java

// 方式1：继承Thread类
class MyThread extends Thread {  
    @Override  
    public void run() {  
        System.out.println("Thread running: " + Thread.currentThread().getName());  
    }  
}  

// 方式2：实现Runnable接口  
Runnable task = () -> System.out.println("Runnable task: " + Thread.currentThread().getName());  
new Thread(task).start();  

// 方式3：FutureTask + Callable（获取返回值）  
Callable<Integer> callable = () -> { return 42; };  
FutureTask<Integer> futureTask = new FutureTask<>(callable);  
new Thread(futureTask).start();  
System.out.println("Result: " + futureTask.get());  

Demo2：synchronized锁的两种用法

java

// 1. 同步代码块  
public void add() {  
    synchronized(this) {  
        count++;  
    }  
}  

// 2. 同步方法  
public synchronized void subtract() {  
    count--;  
}  

Demo3：ReentrantLock公平锁 vs 非公平锁

java

ReentrantLock lock = new ReentrantLock(true); // true为公平锁  
lock.lock();  
try {  
    // 临界区代码  
} finally {  
    lock.unlock();  
}  

Demo4：线程池参数调优实战

java

ExecutorService executor = new ThreadPoolExecutor(  
    4, // 核心线程数  
    8, // 最大线程数  
    60, // 空闲线程存活时间  
    TimeUnit.SECONDS,  
    new LinkedBlockingQueue<>(100), // 任务队列  
    Executors.defaultThreadFactory(),  
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略  
);  

// 提交任务  
executor.submit(() -> System.out.println("Task executed by " + Thread.currentThread().getName()));  

Demo5：CountDownLatch实现并行任务汇总

java

CountDownLatch latch = new CountDownLatch(3);  

// 三个子线程执行任务  
for (int i = 0; i < 3; i++) {  
    new Thread(() -> {  
        System.out.println("子线程完成任务");  
        latch.countDown();  
    }).start();  
}  

latch.await(); // 主线程等待  
System.out.println("所有子线程执行完毕，继续主线程");  

Demo6：CompletableFuture异步编排（Java8+）

java

CompletableFuture.supplyAsync(() -> "Hello")  
    .thenApplyAsync(s -> s + " World")  
    .thenAcceptAsync(System.out::println);  

四、多线程避坑指南（血泪经验总结）

1. 死锁四大条件：互斥、请求与保持、不可剥夺、循环等待
   → 解决方案：统一加锁顺序、设置超时时间
2. 线程池参数误区
3. 核心线程数=CPU核数？
4. I/O密集型任务：核心数 = 2*CPU核数
5. CPU密集型任务：核心数 = CPU核数 + 1
6. ThreadLocal内存泄漏
7. 必须手动remove()！
8. 使用弱引用优化（但治标不治本）
9. volatile的陷阱
10. 能保证可见性，但无法保证原子性
11. 适用场景：单写多读（如状态标志位）

五、高并发实战：设计一个秒杀系统

核心思路：

1. 前端限流：按钮置灰、验证码
2. 库存预扣减：Redis分布式锁 + Lua脚本原子操作
3. 请求削峰：MQ异步处理订单
4. 兜底策略：数据库最终一致性校验

java

// 伪代码示例：Redis扣减库存  
String key = "seckill:stock:" + productId;  
String script = "if redis.call('get', KEYS[1]) > 0 then redis.call('decr', KEYS[1]) return 1 else return 0 end";  
Long result = redisTemplate.execute(  
    new DefaultRedisScript<>(script, Long.class),  
    Collections.singletonList(key)  
);  
if (result == 1) {  
    // 生成订单  
}  

六、免费福利 & 下期预告

福利：
关注并私信“并发”，免费领取：

• 《Java并发编程实战》电子书
• 大厂高并发面试题集（含答案）
• 线程池参数计算工具

下期预告：
《Java内存泄漏排查实战：从MAT到Arthas，手把手教你揪出元凶！》