单例模式的实现

要解决的问题：所谓的单例模式，就是采用一定的方法保证整个的软件系统中， 对某个类只能存在一个对象实例。
两种方式的对比：
饿汉式：
坏处：对象加载时间过长
好处：饿汉式是线程安全的

懒汉式：
好处：延迟对象的创建
懒汉式1：线程不安全
懒汉式2：线程安全

饿汉式1：

package singletonpattern;
class Bank{
    //1.私有化类的构造器
    private Bank(){
    }
    //2.内部创建类的对象
    //3.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

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

饿汉式2：使用了静态代码块

class Order{
    //1.私有化类的构造器
    private Order(){
    }
    //2.声明当前对象，没初始化
    //3.此对象也必须声明为static的
    private static Order instance = null;
    static{
        instance = new Order();
    }
    //4.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        return instance;
    }
}

懒汉式1：线程不安全

class Car{
    //1.私有化类的构造器
    private Car(){
    }
    //2.声明当前类的对象，没初始化
    //3.此对象也必须声明为static的
    private static Car instance = null;
    
    //4.声明public、static的返回当前类的对象的方法
    public static Car getInstance(){
        if(instance == null){
            instance = new Car();
        }
        return instance;
    }
}

懒汉式二：使用同步机制将单例模式中的懒汉式改写为线程安全的

class Bank{
    private Bank(){
    }
    private static Bank instance = null;

    public static Bank getInstance(){
        if(instance == null){
            synchronized(Bank.class){
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

补充：同步代码块

 synchronized(同步监视器){
      //需要被同步的代码
 }

说明：

• 1.操作共享数据的代码，即为需要被同步的代码。不能包含代码多了，也不能包含代码少了。
• 2.共享数据：多个线程共同操作的变量。
• 3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
• 4.要求：多个线程必须要共用同一把锁。