Java 多线程核心：线程安全机制与单例模式实现

② 可重入性

对同一个线程再次加锁时，不会产生死锁。这是 synchronized 的默认行为。

public class Demo15 {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t = new Thread(() -> {
            synchronized (lock) {
                synchronized (lock) {
                    System.out.println("hh");
                }
            }
        });
        t.start();
    }
}

3. 死锁的四大必要条件

面试常考点。只有同时满足以下四种情况才会产生死锁：

1. 互斥性：资源一次只能被一个线程占用。
2. 不可被抢占：已获得的锁不能被强制剥夺。
3. 保持再请求：线程持有资源的同时请求新资源。
4. 循环等待：等待链形成闭环。

注意：如果只有一把锁且具备可重入性，不会死锁；多把锁若不嵌套使用，通常也不会死锁。

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); }
                synchronized (lock2) {
                    System.out.println("t1");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); }
                synchronized (lock1) {
                    System.out.println("t2");
                }
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

4. 死锁的三大场景

1. 一个线程一把锁：可重入锁可解决。
2. 两个线程两把锁：如上述示例，需避免交叉锁定。
3. M 个线程 N 把锁：典型如哲学家就餐问题，同时就餐易导致死锁。

5. wait() 与 notify() 方法

wait() 主要用于控制线程执行顺序，它会在释放锁的同时让当前线程进入等待状态。

wait 与 sleep 的区别：

1. wait 释放锁，sleep 不释放锁。
2. wait 必须在 synchronized 块中使用，sleep 任意位置均可。
3. wait 可被 notify 唤醒，sleep 必须等到时间结束。

public class Demo17 {
    public static void main(String[] args) {
        Object locker = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("t1 wait 之前");
                try { locker.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); }
                System.out.println("t1 wait 之后");
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("t2 wait 之前");
                try { locker.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); }
                System.out.println("t2 wait 之后");
            }
        });

        Thread t3 = new Thread(() -> {
            java.util.Scanner scanner = new java.util.Scanner(System.in);
            System.out.println("输入任意内容结束线程：");
            scanner.next();
            synchronized (locker) {
                locker.notifyAll();
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

此外，wait 支持超时设置，避免无限等待；notifyAll 可唤醒所有等待线程。

6. 内存可见性问题

一个线程修改了变量，另一个线程可能看不到这个修改。这通常源于编译器优化或 CPU 缓存。

原理： JMM 允许线程将主内存变量拷贝到工作内存中操作，读写工作内存而非每次都访问主内存。若修改未同步回主内存，其他线程读取到的就是旧值。

解决方案： 使用 volatile 修饰变量。

public class Demo16 {
    private static volatile boolean flag = true;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (flag) {
                // 持续检查
            }
            System.out.println("线程 t1 结束");
        });

        Thread t2 = new Thread(() -> {
            java.util.Scanner scanner = new java.util.Scanner(System.in);
            System.out.println("输入任意内容结束线程 t1");
            scanner.next();
            flag = false;
            System.out.println("flag = " + flag);
        });

        t1.start();
        t2.start();
    }
}

volatile 强制线程每次读取变量时必须从主内存读取，修改后立即写回主内存，禁止使用工作内存中的缓存副本。

二、单例模式

1. 饿汉模式

• 特点：类加载时就创建实例。
• 优点：实现简单，天生线程安全（无写操作）。
• 缺点：若未使用则浪费资源。

public class Singleton {
    private static Singleton singleton = new Singleton();

    public static Singleton getSingleton() {
        return singleton;
    }

    private Singleton() {}
}

2. 懒汉模式

• 特点：第一次调用时才创建实例。
• 优点：按需加载，节省资源。
• 缺点：存在线程安全问题，需处理同步。

public class SingletonLazy {
    private static volatile SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }

    private SingletonLazy() {}
}

3. 线程安全的单例模式（DCL）

针对指令重排序问题，双重检查锁（Double-Checked Locking）是典型方案。

原理： new 操作非原子，包含分配内存、初始化、赋值三步。极端情况下，CPU 可能重排序导致先赋值后初始化，其他线程拿到未初始化的对象。

public class SingletonDCL {
    private static volatile SingletonDCL instance = null;
    private static Object locker = new Object();

    public static SingletonDCL getInstance() {
        if (instance == null) {
            synchronized (locker) {
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }

    private SingletonDCL() {}
}

关键点：

1. 双重判断：第一次检查避免不必要的加锁，提升性能；第二次检查防止重复创建。
2. volatile：禁止指令重排序，确保初始化在赋值之前完成。

总结： synchronized 保证原子性，双重 if 减少锁竞争，volatile 解决可见性与重排序。三者配合，确保 DCL 单例的安全高效。