使用同步机制解决单例模式中的懒汉式的线程安全问题

package day2_4;

import org.junit.Test;

/**
 * 单例设计模式
 * 1.1是什么
 * 就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
 * 1.2 好处
 * 由于单例模式只生成一个实例，减少了系统性能的开销，当一个对象的产生需要比较多的资源
 * 时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时产生一个单例对象，然后永久
 * 驻留内存的方式来解决
 * <p>
 * 2.如何实现？
 * 饿汉式 vs 懒汉式
 * <p>
 * 3.区别
 * 饿汉式：（可以看看Runtime源码）
 * 坏处：提前把对象就创建好了，但是有可能很久才会用，或者一直也用不上，就导致对象加载时间过长
 * 好处：线程安全的
 * 懒汉式：
 * 坏处：需要使用同步机制解决线程安全的问题
 * 好处：延迟对象的创建，什么时候用就什么时候创建
 */
public class SingletonTest {
    @Test
    public void test1() {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1);
        System.out.println(bank2);
        System.out.println(bank2 == bank1);
    }

    @Test
    public void test2() {
        Order Order1 = Order.getInstance();
        Order Order2 = Order.getInstance();
        System.out.println(Order1);
        System.out.println(Order2);
        System.out.println(Order2 == Order2);
    }
}

//饿汉式（不管你用不用提前就创建好对象）
class Bank {
    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的（为了步骤3调用）
    private static Bank instance = new Bank();

    //1.私有化类的构造器
    private Bank() {
    }

    //3.提供公共的静态方法，返回类的对象
    public static Bank getInstance() {
        return instance;
    }
}

//懒汉式(用的时候才创建对象) 有线程安全问题
//class Order{
//
//    private static Order instance = null;
//
//    private Order(){
//    }
//
//    public static Order getInstance() {
//        if (instance == null) {
//            instance = new Order();
//        }
//        return instance;
//    }
//}

//懒汉式(用的时候才创建对象) 需要解决线程安全问题
class Order {
    private static Order instance = null;

    private Order() {

    }

    //方式一：同步的静态方法，同步监视器是Order的类对象Order.class
//    public static synchronized Order getInstance() {
//        if (instance == null) {
//            instance = new Order();
//        }
//        return instance;
//    }

    //方式二：同步代码块（Surround With（Ctrl+Alt+T快捷键 ））
//    public static synchronized Order getInstance() {
//        synchronized (Order.class) {
//            if (instance == null) {
//                instance = new Order();
//            }
//            return instance;
//        }
//    }

    //上面两种方式都是正确的，但效率低点
    //方式三：如果同步代码块中需要执行的操作比较多，下面的方式效率会高些
    public static synchronized Order getInstance() {
        //第一批第一个进入同步代码块的线程会不受干扰的创建对象，并返回这个对象
        //后一批的线程在判断instance == null为false后，都不会再加入同步
        // 代码块，这样效率更高！
        if (instance == null) {
            synchronized (Order.class) {
                if (instance == null) {
                    instance = new Order();
                }
            }
        }
        return instance;
    }
}