反射 序列化 克隆对单例模式的破坏

2019独角兽企业重金招聘Python工程师标准>>>

所谓单例模式就是，某一个类只能有一个实例，实现的核心就是将类的构造函数私有化，只能由该类创建对象，其他对象就不能调用该类的构造函数，即不能创建对象了。

现在看一个问题：对象的创建方式有哪几种？ 
四种：new 、克隆、序列化、反射。

其实上面的说法有点问题，改为：……其他对象就不能调用该类的构造函数，即不能通过new 来创建对象了。那么是否还有可以通过其他的三种方式创建对象呢，即其他三种方式会不会破坏单例模式呢？

• 克隆可能对单例模式的破坏

  由克隆我们可以想到原型模式，原型模式就是通过clone方法实现对象的创建的，clone方式是Object方法，每个对象都有，那我使用一个单例模式类的对象，调用clone方法，再创建一个新的对象了，那岂不是上面说的单例模式失效了。当然答案是否定，某一个对象直接调用clone方法，会抛出异常，即并不能成功克隆一个对象。调用该方法时，必须实现一个Cloneable 接口。这也就是原型模式的实现方式。还有即如果该类实现了cloneable接口，尽管构造函数是私有的，他也可以创建一个对象。即clone方法是不会调用构造函数的，他是直接从内存中copy内存区域的。所以单例模式的类是不可以实现cloneable接口的。

• 序列化可能对单例模式的破坏

  一是可以实现数据的持久化；二是可以对象数据的远程传输。 
  如果过该类implements Serializable，那么就会在反序列化的过程中再创一个对象。这个问题的解决办法就是在反序列化时，指定反序化的对象实例。添加如下方法：

 private static final long serialVersionUID = -3979059770681747301L;

    private volatile static Singleton singleton;

    private Object readResolve() {
        return singleton;
    }

• 反射可能对单例模式的破坏

反射是可以获取类的构造函数，再加一行 setAccessible(true);就可以调用私有的构造函数，创建对象了。那么防止反射破坏Java单例模式的方法就是：当第二次调用构造函数时抛出异常。代码如下：

private volatile static Singleton1 singleton;

    private  static boolean  flag = true;
    private Singleton1 (){
        if(flag){
        flag = false;   
        }else{
            throw new RuntimeException("单例模式险些被破坏，第二个对象未创建成功");
        }

    }

还有一种方式是通过枚举实现。

下面开始正式讲单例模式方式： 
最好的就是双重检测校检锁，不过下面将全部的几种方式都写出来。 
1、线程不安全：懒汉： （懒汉就是延迟加载）

 package com.txc.singleton;

import java.io.Serializable;
//线程不安全：懒汉 
public class Singleton2 implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 2857896192197905033L;

    private volatile static Singleton2 singleton;
    private  static boolean  flag = true;
    private Singleton2 (){
        if(flag){
        flag = false;   
        }else{
            throw new RuntimeException("单例模式险些被破坏，第二个对象未创建成功");
        }

    }

    public static Singleton2 getInstance() {  
        if (singleton == null) {  
            singleton = new Singleton2();  
        }  
        return singleton;  
        }  
    private Object readResolve() {
        return singleton;
    }
}

2、线程安全：懒汉：

package com.txc.singleton;

import java.io.Serializable;
//线程不安全：懒汉 
public class Singleton3 implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 2857896192197905033L;

    private volatile static Singleton3 singleton;

    private  static boolean  flag = true;
    private Singleton3 (){
        if(flag){
        flag = false;   
        }else{
            throw new RuntimeException("单例模式险些被破坏，第二个对象未创建成功");
        }

    }

    public static synchronized  Singleton3 getInstance() {  
        if (singleton == null) {  
            singleton = new Singleton3();  
        }  
        return singleton;  
        }  
    private Object readResolve() {
        return singleton;
    }
}

3、饿汉：（非延迟加载）是线程安全的。

package com.txc.singleton;

import java.io.Serializable;
//线程不安全：懒汉 
public class Singleton4 implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 2857896192197905033L;

    private  static Singleton4 singleton= new Singleton4(); 

   private  static boolean  flag = true;
    private Singleton4 (){
        if(flag){
        flag = false;   
        }else{
            throw new RuntimeException("单例模式险些被破坏，第二个对象未创建成功");
        }

    }

    public static  Singleton4 getInstance() {  
        return singleton;  
    }  
    private Object readResolve() {
        return singleton;
    }
}

4、枚举

public enum Singleton {  
    INSTANCE;  

} 

5、双重校检锁

package com.txc.singleton;

import java.io.Serializable;

public class Singleton1 implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = -3979059770681747301L;

    private volatile static Singleton1 singleton;


    private  static boolean  flag = true;
    private Singleton1 (){
        if(flag){
        flag = false;   
        }else{
            throw new RuntimeException("单例模式险些被破坏，第二个对象未创建成功");
        }

    }

    public static Singleton1 getSingleton() {
        if (singleton == null) {
            synchronized (Singleton1.class) {
                if (singleton == null) {
                    singleton = new Singleton1();
                }
            }
        }
        return singleton;
    }

    private Object readResolve() {
        return singleton;
    }

}

如有错误，请指出。

转载于:https://my.oschina.net/u/3568600/blog/1827375