Java单例模式的几种实现

就是说，有时候某个类需要频繁地创建对象、销毁对象，或者运行环境中只允许某个类只有一个对象存在。这时候就需要用到单例模式。
单例模式有两个要点：
1）构造器私有
2）唯一的一个实例是静态变量
几种实现：
1.饿汉式
1.1直接new

public class Singleton {
    private Singleton(){}
    public static Singleton instance = new Singleton();
}
public class Test {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.instance;
        Singleton singleton2 = Singleton.instance;
        System.out.println(singleton1==singleton2);
    }
}
true

1.2枚举类

public enum SingletonEnum {
    INSTANCE;
}
public class Test {
    public static void main(String[] args) {
        SingletonEnum singletonEnum1 = SingletonEnum.INSTANCE;
        SingletonEnum singletonEnum2 = SingletonEnum.INSTANCE;
        System.out.println(singletonEnum1==singletonEnum2);
    }
}
true

2.懒汉式
2.1判断一下再new，但是这样线程不安全

public class SingletonNotSafe {
    private SingletonNotSafe(){}
    public static SingletonNotSafe instance;
    public static SingletonNotSafe getInstance(){
        if(instance==null){
            instance = new SingletonNotSafe();
        }
        return instance;
    }
}
public class Test {
    public static void main(String[] args) {
        new Thread(()->{
            SingletonNotSafe singletonNotSafe1 = SingletonNotSafe.getInstance();
            System.out.println(singletonNotSafe1);
        }).start();
        new Thread(()->{
            SingletonNotSafe singletonNotSafe2 = SingletonNotSafe.getInstance();
            System.out.println(singletonNotSafe2);
        }).start();
    }
}
lazyMan.nornal.SingletonNotSafe@2d2d936c
lazyMan.nornal.SingletonNotSafe@72d6db17

2.2双重锁，免得不为null的时候还要排队

public class SingletonSafeLock {
    private SingletonSafeLock(){};
    public static SingletonSafeLock instance;
    public static SingletonSafeLock getInstance(){
        if(instance==null){
            synchronized (SingletonSafeLock.class){
                if(instance==null){
                    instance = new SingletonSafeLock();
                }
            }
        }
        return instance;
    }
}
public class Test {
    public static void main(String[] args) {
        new Thread(()->{
            SingletonSafeLock singletonSafeLock1 = SingletonSafeLock.getInstance();
            System.out.println(singletonSafeLock1);
        }).start();
        new Thread(()->{
            SingletonSafeLock singletonSafeLock2 = SingletonSafeLock.getInstance();
            System.out.println(singletonSafeLock2);
        }).start();
    }
}
lazyMan.safe.SingletonSafeLock@42b95647
lazyMan.safe.SingletonSafeLock@42b95647

2.3内部类开整，自带单例模式+线程安全

public class SingletonSafeLoad {
    private SingletonSafeLoad(){};
    public static class Inside{
        public static SingletonSafeLoad instance = new SingletonSafeLoad();
    }
}
public class Test {
    public static void main(String[] args) {
        SingletonSafeLoad singletonSafeLoad1 = SingletonSafeLoad.Inside.instance;
        SingletonSafeLoad singletonSafeLoad2 = SingletonSafeLoad.Inside.instance;
        System.out.println(singletonSafeLoad1==singletonSafeLoad2);
    }
}
true