写在前面

开发者痛点：在实际项目中，经常会被问到「单例到底该怎么写才不会在高并发下出问题？」、「生产者使用者实现不当会不会导致线程卡死？」还有「线上出现死锁该怎么快速定位？」这些看似基础却极易踩坑的问题。下面把这三大经典难点一次性梳理清楚，帮助你在面试和实战中都能胸有成竹。不过，

一、单例模式：各种写法的线程安全全景

1️⃣ 饿汉式

// 饿汉式：类加载时就创建。天然线程安全，代价是不管用不用都占着这份内存
public class Singleton1 {
private static final Singleton1 INSTANCE = new Singleton1;private Singleton1 {}
public static Singleton1 getInstance { return INSTANCE;}
}

2️⃣ 懒汉式

// 懒汉式：用到才创建。但线程不安全——两个线程可能同时通过if判断，各自new出一个实例
public class Singleton2 {
private static Singleton2 instance;private Singleton2 {}
public static Singleton2 getInstance {
if {
instance = new Singleton2;话说回来，// 并发场景下这里可能被创建两次
}
return instance;}
}

3️⃣ 同步方法懒汉式

// 同步方法懒汉式：加synchronized解决了线程安全。但每次调用都要抢锁，性能差
public class Singleton3 {
private static Singleton3 instance;private Singleton3 {}
public static synchronized Singleton3 getInstance {
if {
instance = new Singleton3;其实，}
return instance;}
}

4️⃣ 静态内部类

// 静态内部类：借助类加载机制实现懒加载+线程安全，且没有锁开销
public class Singleton4 {
private Singleton4 {}
private static class Holder {
private static final Singleton4 INSTANCE = new Singleton4;}
public static Singleton4 getInstance { return Holder.INSTANCE;}
}

5️⃣ 枚举单例

// 枚举单例：写法最简单，JVM保证枚举实例全局唯一
public enum Singleton5 {
INSTANCE;public void doSomething { /* ... */ }
}

⚡️ 开发者痛点提示：很多同学在使用双检锁时忘记给 instance 加 volatile导致指令重排出现隐藏的多实例问题。下面简要回顾一下 DCL 的关键点：

public class SingletonDCL {
private static volatile SingletonDCL instance;private SingletonDCL {}
public static SingletonDCL getInstance {
if {
synchronized {
if {
instance = new SingletonDCL;// 必须是 volatile 才能防止重排
}
}
}
return instance;话说回来，}
}

DCL 能兼顾懒加载、线程安全还有仅首次加锁。但代码复杂且极易遗漏 volatile。相比之下静态内部类实现既简单又高效，是大多数业务场景的首选。说起来，

二、生产者使用者模型：三种实现方式怎么选？

a. 最原始的 wait / notify 实现

class Buffer {
private final Queue queue = new LinkedList<>;private final int capacity;public Buffer { this.capacity = capacity;}
public synchronized void put throws InterruptedException {
while == capacity) { // 满了生产者等待
wait;// 只能被 notifyAll 唤醒后重新竞争锁
}
queue.offer;notifyAll，// 醒所有等待者
}
public synchronized int take throws InterruptedException {
while ) { // 空了使用者等待
wait;
按理说，}
int value = queue.poll;不过，notifyAll;说起来，// 醒所有等待者
return value;}
}

Pain Point：在业务代码里自行编写 wait/notify 时经常会遇到「所有线程都被唤醒。却只有少数满足条件，其余又重新进入等待」导致 CPU 无意义循环。话说回来，

b. Lock + Condition

使用 AQSLock + Condition.notFull / notEmpty 可以为生产者和使用者分别维护独立的等待队列。从而避免无效唤醒，老实说，