1.设计模式之单例模式（饿汉式、懒汉式）

单列模式

单例模式就是说，在整个软件系统中，对于某一个类，只存在一个实例。

单例模式分为两种，饿汉式和懒汉式

饿汉式是在类加载时就创建实例

优点：
1.写法简单，容易理解
2.在类加载时就创建实例，避免了线程同步问题
缺点：
1.如果系统不需要使用这个实例，但在类加载时会自动创建，会造成内存浪费

代码实现：
1.将构造器私有化
2.私有化创建一个实例
3.公开一个获得实例的方法

public class Singleton01 {
    public static void main(String[] args) {
        //获取两个实例
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        //判断两个实例是否相同
        System.out.println(singleton == singleton1);
        //两个实例的hashCode
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton{
    //构造器私有化
    private Singleton(){
    };

    //创建一个静态实例
    private static Singleton instance = new Singleton();

    //公开一个获取静态实例的静态方法
    public static Singleton getInstance(){
        return instance;
    }
}

还有一种静态代码块的方式，先了解一下什么是静态代码块。

随着类的加载而执行，而且只执行一次，执行优先级高于非静态的初始化块，它会在类初始化的时候执行一次，执行完成便销毁，它仅能初始化类变量，即static修饰的数据成员。

public class Singleton02 {
    public static void main(String[] args) {
        //获取两个实例
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        //判断两个实例是否相同
        System.out.println(singleton == singleton1);
        //两个实例的hashCode
        System.out.println(singleton.hashCode());
        System.out.println(singleton1.hashCode());
    }
}

class Singleton{
    //构造器私有化
    private Singleton(){
    };
    //创建一个静态变量
    private static Singleton instance;
    //静态代码块，类加载后销毁
    static{
       instance =  new Singleton();
    }
    //公开一个获取静态实例的静态方法
    public static Singleton getInstance(){
        return instance;
    }
}

懒汉式是需要使用时创建实例
双重检查

public class SingletonTest5 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println(singleton1.hashCode());
        System.out.println(singleton2.hashCode());
    }
}

class Singleton{
    private Singleton(){};
    private static volatile Singleton instance;

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

静态内部类

public class SingletonTest6 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println(singleton1.hashCode());
        System.out.println(singleton2.hashCode());
    }
}

class Singleton{
    private Singleton(){};
   // private static Singleton instance;

    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

枚举

public class SingletonTest7 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.INSTANCE;
        Singleton singleton2 = Singleton.INSTANCE;
        System.out.println(singleton1 == singleton2);
        System.out.println(singleton1.hashCode());
        System.out.println(singleton2.hashCode());
        singleton1.sayOk();
        singleton2.sayOk();
    }
}

enum Singleton{
    INSTANCE;
    public void sayOk(){
        System.out.println("ok");
    }
}