单例模式及破坏单例及防破坏单例方式-优快云博客

本文详细介绍了Java中的单例模式，包括懒汉式、饿汉式以及DCL双检锁机制的实现。讨论了volatile关键字在多线程环境中的作用，如何防止单例模式被反射和序列化破坏，并提出枚举实现单例模式作为最安全的选择。同时，总结了不同单例模式的优缺点和应用场景。

在多线程环境下使用DCL（双关检锁机制）是否就百分百OK呢？

单例模式

单例模式代码模式步骤

1.私有类构造方法，防止外部创建。

2.私有静态volatile修饰类成员变量。防止指令重排

3.公有静态Double Check + Lock 方式获取单例实例化方法

如下demo code

public class Singleton {
    
    private static volatile Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

什么是DCL双关检锁机制？

加锁前后都进行一次判断。

直接上代码理解，DCL（双关检锁机制）代码：

package com.javaliao.backstage;
 
 
public class Demo {
 
    private static Demo demo = null;
 
    private Demo(){
        System.out.println(Thread.currentThread().getName()+"\t 构造方法");
    }
 
    public static  Demo getInstance(){
        if(demo == null){
            synchronized (Demo.class){
                if(demo == null){
                    demo = new Demo();
                }
            }
        }
        return demo;
    }
 
    //主线程main，程序入口
    public static void main(String[] args) {
 
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                Demo.getInstance();
            },String.valueOf(i)).start();
        }
    }
 
}

为什么要加二层判断呢？更加牢固一些

打个比方：你上厕所，你确认没有人了，然后再进去，进去了把门插上，再推一下门，推不动确认安全后该干啥干啥。

在多线程环境下使用DCL（双关检锁机制）是否就百分百OK呢？

不是，DCL（双关检锁机制）不一定线程安全，在多线程环境下，JMM中的有序性会让指令出现重排，让执行顺序发送变化，不能保证百分百。加入volatile可以禁止指令重排

单例模式volatile分析

在多线程环境下，当一条线程访问instance不为null时，由于instance实例未必已初始化完成，造成线程安全问题。

所以加上volatile才可以保证百分百ok。

public class Demo {
 
    private static volatile Demo demo = null;
 
    private Demo(){
        System.out.println(Thread.currentThread().getName()+"\t 构造方法");
    }
 
    public static  Demo getInstance(){
        if(demo == null){
            synchronized (Demo.class){
                if(demo == null){
                    demo = new Demo();
                }
            }
        }
        return demo;
    }
 
    //主线程main，程序入口
    public static void main(String[] args) {
 
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                Demo.getInstance();
            },String.valueOf(i)).start();
        }
    }
 
}

破坏单例方式

破坏懒汉式单例与饿汉式单例

无论是完美的懒汉式还是饿汉式，终究敌不过反射和序列化，它们俩都可以把单例对象破坏掉（产生多个对象）。

利用反射破坏单例模式

下面是一段使用反射破坏单例模式的例子

public static void main(String[] args) {
    // 获取类的显式构造器
    Constructor<Singleton> construct = Singleton.class.getDeclaredConstructor();
    // 可访问私有构造器
    construct.setAccessible(true); 
    // 利用反射构造新对象
    Singleton obj1 = construct.newInstance(); 
    // 通过正常方式获取单例对象
    Singleton obj2 = Singleton.getInstance(); 
    System.out.println(obj1 == obj2); // false
}

上述的代码一针见血了：利用反射，强制访问类的私有构造器，去创建另一个对象。

利用序列化与反序列化破坏单例模式

下面是一种使用序列化和反序列化破坏单例模式的例子

public static void main(String[] args) {
    // 创建输出流
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.file"));
    // 将单例对象写到文件中
    oos.writeObject(Singleton.getInstance());
    // 从文件中读取单例对象
    File file = new File("Singleton.file");
    ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
    Singleton newInstance = (Singleton) ois.readObject();
    // 判断是否是同一个对象
    System.out.println(newInstance == Singleton.getInstance()); // false
}

两个对象地址不相等的原因是：readObject() 方法读入对象时它必定会返回一个新的对象实例，必然指向新的内存地址。

枚举实现单例模式及防止被破坏

枚举实现单例模式完整代码如下：

public enum Singleton {
    
    INSTANCE;
    
    public void doSomething() {
        System.out.println("这是枚举类型的单例模式！");
    }
}

使用枚举实现单例模式较其它两种实现方式的优势有 3 点，让我们来细品。

优势 1 ：一目了然的代码

代码对比饿汉式与懒汉式来说，更加地简洁。最少只需要3行代码，就可以完成一个单例模式：

public enum Singleton {
    INSTANCE;
}

我们从最直观的地方入手，第一眼看到这3行代码，就会感觉到少，没错，就是少，虽然这优势有些牵强，但写的代码越少，越不容易出错。

优势 2：天然的线程安全与单一实例

它不需要做任何额外的操作，就可以保证对象单一性与线程安全性。

我写了一段测试代码放在下面，这一段代码可以证明程序启动时仅会创建一个 Singleton 对象，且是线程安全的。

我们可以简单地理解枚举创建实例的过程：在程序启动时，会调用 Singleton 的空参构造器，实例化好一个Singleton 对象赋给 INSTANCE，之后再也不会实例化

public enum Singleton {
    INSTANCE;
    Singleton() { System.out.println("枚举创建对象了"); }
    public static void main(String[] args) { /* test(); */ }
    public void test() {
        Singleton t1 = Singleton.INSTANCE;
        Singleton t2 = Singleton.INSTANCE;
        System.out.print("t1和t2的地址是否相同：" + t1 == t2);
    }
}
// 枚举创建对象了
// t1和t2的地址是否相同：true

除了优势1和优势2，还有最后一个优势是 保护单例模式，它使得枚举在当前的单例模式领域已经是 无懈可击 了