单例模式

核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

• 保证只有一个实例：可以将该类设置为static，并将其构造器私有。
• 提供一个访问该实例的全局访问点，比如get()方法。

优点

• 由于单例模式只生成一个实例，减少了系统性能的开销。
• 单例模式可以在系统设置全局访问点，优化共享资源访问。

 常见的五种单例模式实现方式

• 饿汉式（线程安全，调用效率高，不能延时加载）
• 懒汉式（线程安全，调用效率不高，可以延时加载）
• DCL懒汉式（由于JVM底层内部模型原因，偶尔会出现问题，不建议使用）
• 饿汉式改进：静态内部类式（线程安全，调用效率高，可以延时加载）
• 枚举单例（线程安全，调用效率高，不能延时加载）

实例

 1.饿汉式：

/*
 * 饿汉式单例
 * 如果有“费代码”，会开辟内存空间，造成浪费
 */
public class SingletonDemo {
    //私有化构造方法
    private SingletonDemo(){
    }

    //static修饰，类初始化时，立即加载该对象
    private static SingletonDemo instance = new SingletonDemo();

    //提供获取该对象的方法，没有synchronized，效率高
    public static SingletonDemo getInstance(){
        return instance;
    }
}

2.懒汉式：

/*
 * 懒汉式单例
 */
public class SingletonDemo2 {
    //私有化构造器
    private SingletonDemo2(){
    }
    //类加载到内存时，不立即加载该对象
    private static SingletonDemo2 instance;

    //提供获取该对象的方法，有synchronized，效率低
    public static synchronized SingletonDemo2 getInstance(){
        if (instance == null){
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

3.DCL懒汉式（双重检测锁）：

/*
 * 双重检测锁DCL懒汉式
 */
public class SingletonDemo3 {
    //私有化构造器
    private SingletonDemo3(){
    }

    //volatile：保证原子性和一致性
    private volatile static SingletonDemo3 instance;

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

        return instance;
    }
}

4.静态内部类：
 

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/*
 * 静态内部类实现
 * 保证线程安全，又懒加载
 * 但通过反射机制，仍然可以破坏掉单例模式
 */
public class SingletonDemo4 {

    //私有化构造方法
    private SingletonDemo4(){
    }
    //静态内部类
    private static class innerClass{
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }

    public static SingletonDemo4 getInstance(){
        return innerClass.instance;
    }
}

//通过反射机制，可以破坏以上单例
class ReflectTeat{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        SingletonDemo4 instance = SingletonDemo4.getInstance();
//        SingletonDemo4 instance1 = SingletonDemo4.getInstance();
//        System.out.println(instance == instance1);   //此时返回true

        Constructor<SingletonDemo4> declaredConstructor = SingletonDemo4.class.getDeclaredConstructor(null);
        //通过setAccessible()方法，无视私有
        declaredConstructor.setAccessible(true);
        SingletonDemo4 instance2 = declaredConstructor.newInstance();
        System.out.println(instance == instance2); //返回false
    }
}

5.枚举：

import java.sql.SQLOutput;

/*
 * 枚举
 */
public enum SingletonDemo5 {
    INSTANCE;

    public SingletonDemo5 getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) {
        SingletonDemo5 instance1 = SingletonDemo5.INSTANCE;
        SingletonDemo5 instance2 = SingletonDemo5.INSTANCE;
        System.out.println(instance1 == instance2);//返回值为：true
    }
    
}