Java 多线程进阶：线程安全与单例模式

②可重入性

就是在对同一个线程再次加锁时，不会产生死锁

package JavaEE;
public class Demo15 {
    // synchronized 的可重入性，使这里不会死锁
    public static void main(String[] args) {
        Object lock1 = new Object();
        Thread t = new Thread(() -> {
            synchronized (lock1) {
                synchronized (lock1) {
                    System.out.println("hh");
                }
            }
        });
        t.start();
    }
}

3、死锁的四大必要条件（面试重点）

同时满足以下四种情况才会产生死锁

①互斥性 (sychronized 具备)

②不可被抢占 (sychronized 具备)

有的线程可能不会阻塞，直接把锁抢过来

③保持再请求

线程 1 在持有锁 A 的情况下，同时请求锁 B

注意：1、如果通篇只有一把锁，并且具备可重入性，不会死锁

      2、如果多把锁之间不进行嵌套，不会死锁

④循环等待

在满足保持再请求的条件下，等待锁的顺序出现了循环

package JavaEE;
// 最简单的演示死锁方式，重点记忆一下
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 {
                    // 使用 sleep 休眠确保 t2 也拿到了锁
                    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、死锁的三大场景

①一个线程一把锁

可重入的锁可以解决

②两个线程两把锁

上面最近的这个示例

③M 个线程 N 把锁

哲学家就餐问题：一个个就餐时正常，同时就餐时就会出现死锁

5、wait() 与 notify() 方法

wait() 主要起到控制线程执行顺序的作用

wait 与 sleep 的三点区别：

1、wait 使用后释放锁，sleep 使用后仍持有锁 2、wait 只能在 synchronized 中使用，sleep 任何地方都可以 3、wait 可以被 notify 唤醒，sleep 必须要等休眠时间结束

package JavaEE;
import java.util.Scanner;
public class Demo17 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("t1wait 之前");
                try {
                    // t1 通过 wait 释放了锁，并进入等待
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t1wait 之后");
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("t2wait 之前");
                try {
                    // t2 通过 wait 释放了锁，并进入等待
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t2wait 之后");
            }
        });
        Thread t3 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入任意内容结束线程：");
            scanner.next();
            synchronized (locker) {
                // locker.notify();
                // locker.notifyAll();
                // 一直等到出了这里，t3 释放锁，其他线程继续进行
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

另外 wait 后可以设置超时时间，不会死等。notifyAll 可以唤醒所有线程

6、④内存可见性问题 (面试重点)

对于④内存可见性问题

简单说就是：一个线程修改了变量，而另一个线程看不到这个修改

（编译器对读的优化）

示例代码如下：

package JavaEE;
import java.util.Scanner;
public class Demo16 {
    // 发现变量在线程 1 中读取，线程 2 中修改，加上 volatile 就好
    private static boolean flag = true;
    // private static volatile boolean flag = true;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (flag) {
                // Thread.sleep(1);
            }
            System.out.println("线程 t1 结束");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("输入任意内容结束线程 t1");
            Scanner scanner = new Scanner(System.in);
            scanner.next();
            // 修改的是工作内存中的变量，而不是主存里的
            flag = false;
            System.out.println("flag = " + flag);
        });
        t1.start();
        t2.start();
    }
}

它的本质原理是：

JMM(JAVA 内存模型) 为了提高性能，允许每个线程将主内存的变量拷贝到自己的工作内存中操作。线程直接读写工作内存，不每次都访问主内存。这就导致：一个线程修改了工作内存中的变量，但另一个线程看不到这个修改---因为修改还没同步回主内存，或者说另一个线程还在读自己工作内存中的旧值

解决办法：加入 volatile 修饰变量

volatile 的作用就是，强制要求线程每次读取变量时必须从主内存中读取，每次修改完变量以后必须立刻写回主内存，不能使用工作变量中的缓存副本

二、单例模式

1、饿汉模式

• 特点：类加载时就创建实例

• 优点：实现简单，天生线程安全（只有读操作，没有写操作）

• 缺点：如果一直没用到，可能造成资源浪费

package JavaEE;
public class Singleton {
    private static Singleton singleton = new Singleton();
    // 使用静态类，避免进入调用方法需要创建实例，陷入创建实例方面的死循环
    // 直接使用类名就可以调用该方法
    public static Singleton getSingleton() {
        // （只有读操作，没有写操作）
        return singleton;
    }
    // 保证私有，外部不能创建实例
    private Singleton() {};
}

2、懒汉模式

• 特点：第一次调用时才创建实例

• 优点：按需加载，节省资源

• 缺点：需要处理线程安全问题（有写操作）

package JavaEE;
public class SingletonLazy {
    private static volatile SingletonLazy singletonLazy = null;
    public static SingletonLazy getSingletonLazy() {
        if (singletonLazy == null) {
            // 写
            singletonLazy = new SingletonLazy();
        }
        // 读
        return singletonLazy;
    }
    private SingletonLazy() {};
}

3、线程安全的单例模式（面试重点）

单从⑤内存重排序问题上来看

简单说就是：（编译器对写的优化）

package JavaEE;
public class SingletonLazy {
    private static volatile SingletonLazy singletonLazy = null;
    private static Object locker = new Object();
    public static SingletonLazy getSingletonLazy() {
        // 第一次检查：实例是否已经创建？(不用锁，提高性能)
        // 作用：规避不必要的加锁操作
        if (singletonLazy == null) {
            // 加锁，引起锁竞争这样防止同一时间创建多个实例
            synchronized (locker) {
                // 第二次检查：确保同一时间只有一个实例被创建
                // 作用：防止多线程下一个线程创建完，另一个线程又创建
                if (singletonLazy == null) {
                    // 在单例模式下，创建唯一一个 SingletonLazy 类的实例
                    // volatile 关键字解决指令重排序的位置
                    // new 操作非原子性：分配内存 - 初始化 - 赋值
                    singletonLazy = new SingletonLazy();
                }
            }
        }
        return singletonLazy;
    }
    private SingletonLazy() {};
}

它的本质原理是：

指令重排序造成的线程安全问题，DCL(双重检查锁) 单例就可以作为一个典型例子。主要是因为 new 操作不是原子的，它包括分配内存，初始化，赋值三个步骤。在极端情况下，编译器或 CPU 为了优化将初始化和赋值重排序，导致另一个线程拿到一个未初始化的对象

举个例子：

1、线程 A 走到 singletonLazy = new SingletonLazy();，因为重排序，它先赋值了（此时 instance 不再为 null，但指向的是一块还没初始化的内存） 2、线程 B 恰好这时进来检查 if(singletonLazy == null)---发现 singlenLazy 不为 null！ 3、线程 B 直接返回并使用这个 singletonLazy，结果访问到的对象里的数据都是默认值（比如 int 是 0，对象引用是 null），程序出错

解决办法：加入 volatile 修饰变量

volatile 的核心作用就是禁止了这种重排序，保证了初始化操作一定在赋值之前产生，从而保证所有线程看到的都是完整初始化的对象

总结：

锁（synchronized）保证了同一时间只有一个线程的实例被创建，解决了原子性问题

双重 if 判断减少了锁竞争，提升了性能

volatile 通过禁止指令重排序，解决了其他线程看到'半成品'对象的问题

这三者各司其职，共同保证了 DCL 单例的安全和高效