你真的会用单例模式吗？

你真的会用单例模式吗？

说起单例模式，大家都不陌生，它是简单而又经常用的设计模式之一。但是，你真的会用单例模式吗？

完美的单例模式

（1）单例（ps：废话，看名字就知道啦~）
（2）延迟加载
（3）线程安全
（4）没有性能问题
（5）防止反序列化产生新对象

单例模式的实现方式

通常它的实现方式有两种：
1、饿汉式：在定义变量的时候就创建对象

public class MyEngine{
    public static MyEngine instance = new MyEngine();
    private void MyEngine(){
    }
    public static MyEngine getInatance(){
        return instance;
    }
}

实现Serializable接口需要重写readResolve，才能保证其反序列化依旧是单例：

public class MyEngine implement Serializable{
    public static MyEngine instance = new MyEngine();
    private void MyEngine(){
    }
    public static MyEngine getInatance(){
        return instance;
    }
    /** 
     * 如果实现了Serializable, 必须重写这个方法：没有找到这个方法？
     */ 
    private Object readResolve() throws ObjectStreamException { 
        return instance; 
    }
}

2、懒汉式：按需加载

public class MyEngine{
    public static MyEngine instance;
    private void MyEngine(){
    }
    public static MyEngine getInatance(){
        if(instance==null){
           instance  = new MyEngine();
        }
        return instance;
    }
}

public class MyEngine{
    public static MyEngine instance;
    private void MyEngine(){
    }
    public static synchronized MyEngine getInatance(){
        if(instance==null){
           instance  = new MyEngine();
        }
        return instance;
    }
}

public class MyEngine{
    public static MyEngine instance;
    private void MyEngine(){
    }
    public static MyEngine getInatance(){
        if(instance==null){//第一次检查
           synchronized(MyEngine.class){
                if(instance==null){//第二次检查
                    instance  = new MyEngine();
                }
            }
        }
        return instance;
    }
}

如何正确地写出单例模式

给 instance 分配内存
调用 MyEngine 的构造函数来初始化成员变量
将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

我们只需要将 instance 变量声明成 volatile 就可以了。

public class MyEngine{
    public static volatile MyEngine instance;
    private void MyEngine(){
    }
    public static MyEngine getInatance(){
        if(instance==null){//第一次检查
           synchronized(MyEngine.class){
                if(instance==null){//第二次检查
                    instance  = new MyEngine();
                }
            }
        }
        return instance;
    }
}

有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。

相信你不会喜欢这种复杂又隐含问题的方式，当然我们有更好的实现线程安全的单例模式的办法。

其他线程安全方式

我们可以利用JVM加载类的机制去实现同步控制。

1、static final

public class MyEngine{
    //类加载时就初始化
    public static final MyEngine INSTANCE = new MyEngine();
    private void MyEngine(){
    }
    public static MyEngine getInatance(){
        return INSTANCE;
    }
}

2、静态内部类

public class MyEngine{
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，  
     * 而且只有被调用到才会装载，从而实现了延迟加载  
     */
    public static class MyEngineHolder {
        private static final MyEngine INSTANCE = new MyEngine();
    }
    private void MyEngine(){
    }
    public static MyEngine getInatance(){
        return MyEngineHolder.INSTANCE;
    }
}

3、枚举enum

public enum MyEngine{
    INSTANCE;
}

相关阅读:
文件层次结构思维导图
root的密码破解.linux
常用Linux命令
设计模式之-状态模式
ThreadLocal详解及仿写实例
SpringBoot资料
27.枚举
菜鸟python---元组
菜鸟python---列表的增删改查嵌套
菜鸟python---字符串详解

原文地址：https://www.cnblogs.com/hacjy/p/7093737.html

你真的会用单例模式吗？

完美的单例模式

单例模式的实现方式

其他线程安全方式