单例模式,以及防止单利被破坏的几种形式

单利模式：只允许创建一个实例

单利模式的几种实现方式:

• 饿汉式

/**
 *   饿汉式
 *   优点：避免了多线程并发问题
 *   缺点: 创建好的对象不是及时的调用会浪费内存空间
 */
public class Hungry {
    private static Hungry hungry = new Hungry();

    private Hungry(){}

    public static Hungry INSTANCE(){
        return hungry;
    }


}

/**
 * 饿汉式的变种 优缺点跟饿汉式一样
 */
public class Hungry1 {
    private static Hungry1 hungry1;

    static {
        hungry1 = new Hungry1();
    }

    private Hungry1(){}

    public static Hungry1 INSTANCE(){
        return hungry1;
    }
}

• 懒汉式

/**
 * 懒汉式
 * 优点:只有用到这个实例时才会创建  避免了内存空间的浪费
 * 缺点: synchronized 使多线程变成了串行  多线程并发的情况下会影响程序效率
 */
public class Lazy {

    private static Lazy lazy;

    private Lazy() {
    }

    public synchronized static Lazy INSTANCE() {
        if (lazy == null) {
            lazy = new Lazy();
        }
        return lazy;
    }
}

• 懒汉式:双重检查加锁

/**
 * 懒汉式:双重检查加锁
 * 优缺点跟经典懒汉式一致
 * 加入多层判断 保证了不会创建多个实例
 * volatile 关键字 是防止指令重排序
 * lazy =new Lazy1(); 这个代码会发生指令重排序 这段代码在底层执行的时候不是原子操作
 * 事实上在 JVM 中这句话大概做了下面 3 件事情。
 * 1. 给 lazy 分配内存
 * 2. 调用 Lazy1 的构造函数来初始化成员变量，形成实例
 * 3. 将lazy对象指向分配的内存空间（执行完这步lazy才是非 null了）
 * 在JVM的即时编译器中存在指令重排序的优化。
 * 也就是说上面的第二步和第三步的顺序是不能保证的，
 * 最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，
 * 则在 3 执行完毕、2 未执行之前，当前线程停止了，被线程二抢占了，
 * 这时 lazy 已经是非 null 了（这个引用已经指向了分配的内存空间,但却没有初始化），
 * 所以线程二会直接返回 lazy，然后使用，然后顺理成章地报错。
 * 线程的指令重排序:简单的说 就是jvm会对执行的代码指令进行优化处理 有可能会置换两个
 * 没有因果关系的代码指令 进行执行 eg：
 * 1. int a =0
 * 2. int b =1
 * 这个两个赋值  的先后对代码不会有影响 ，那么就会有可能发生指令重排序
 * 执行顺序 有可能 是  1-2  或者 2-1  都是有可能的。
 */
public class Lazy1 {
    private static volatile Lazy1 lazy;

    private Lazy1() {
    }

    public static Lazy1 INSTANCE1() {
        if (lazy == null) {
            synchronized (Lazy1.class) {
                if (lazy == null) {
                    lazy = new Lazy1();
                }
            }
        }
        return lazy;
    }
}

• 静态内部类

/**
 *
 *  静态内部类
 *      在只使用了外部类，但是没有使用内部类的情况下，内部类里面的东西不会被初始化。
 *      这种实现单利模式的方式 既不会浪费内存空间 又不会 有并发的问题
 *
 */
public class StaticInnerClass {
    private StaticInnerClass(){}

    private static class SimpleInstance{
        private static final StaticInnerClass sic = new StaticInnerClass();
    }


    public static StaticInnerClass getInstance(){
        return SimpleInstance.sic;
    }
}

• 注册登记式

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 *  注册登记式
 *      这种实现单利模式  可以维护一组单利实例  spring中采用的就是这种模式
 *
 */
public class RegSingleton implements Serializable{
    private static Map<String,Object> singletonMap = new HashMap();
    static {
        singletonMap.put(RegSingleton.class.getName(),new RegSingleton());
    }
    protected RegSingleton(){}
    public static Object getInstance(String name){
        if(name == null){ name = "RegSingleton"; }
        if(singletonMap.get(name)==null){
            try {
                singletonMap.put(name, Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } }
        return singletonMap.get(name); }
}

• 枚举

/**
 * 你可以通过EasySingleton.INSTANCE来访问，也可以实现单利，这比调用getInstance()方法简单多了。
 */
public enum EasySingleton{
    INSTANCE;
}

 

• 防止反射破坏单利

/**
 * 这种方式可以防止单利被破坏
 */

public class ReflexSingleton {
    private static ReflexSingleton reflexSingleton = new ReflexSingleton();

    private ReflexSingleton() {
        if (reflexSingleton != null) throw new RuntimeException("单利被破坏");
    }

    public static ReflexSingleton getInstance() {
        return reflexSingleton;
    }

    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        try {
            ReflexSingleton reflexSingleton = ReflexSingleton.class.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        ReflexSingleton instance = ReflexSingleton.getInstance();
    }
}

• 序列化和反序列化中的单利模式

package com.swh.design.simgle;

import java.io.*;

/**
 *  假如单利模式实现了序列化  会对单利模式进行破坏
 *  当对象序列化 然后再被反序列化的时候 会创建不同的实体
 *  因为反序列化的底层实现也是用的反射来创建对象的
 *   反序列化的底层代码实现:
 *      private Object readOrdinaryObject(boolean unshared) throws IOException {
 *          Object obj;
 *          try {
 *                  obj = desc.isInstantiable() ? desc.newInstance() : null;   //  此处如果对象实现了序列化Serializable接口，则通过反射创建对象 反射创建对象 会打破封装 创建出新的实例
 *              } catch (Exception ex) {
 *                  throw (IOException) new InvalidClassException(desc.forClass().getName(),
 *                  "unable to create instance").initCause(ex);
 *                  }
 *                  //此处省略部分代码
 *          if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()){ //  如果对象实现了readResolve() 方法  会通过上面创建的对象反射调用该方法
 *              Object rep = desc.invokeReadResolve(obj);
 *              if (unshared && rep.getClass().isArray()) {
 *                  rep = cloneArray(rep);
 *              }
 *          if (rep != obj) {
 *              handles.setObject(passHandle, obj = rep) //  把从readResolve()方法中拿到的返回结果重新复制给obj对象 进行返回
 *                  }
 *              }
 *              return obj;
 *          }
 *
 *       由上面的源码得出  只要对象中提供readResolve() 方法就可以防止反序列化创建新的实例
 *
 */
public class SerializableSingleton implements Serializable{
    private  static  volatile   SerializableSingleton serializableSingleton;
    public SerializableSingleton() {
    }
    public static   SerializableSingleton getInstance(){
        if(serializableSingleton == null) {
            synchronized (SerializableSingleton.class){
                if(serializableSingleton == null) {
                    serializableSingleton = new SerializableSingleton();
                }
            }
        }
        return serializableSingleton;
    }
    private Object readResolve() {
        return serializableSingleton;
    }
    public static void main(String[] args) {
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("serializable"));
            objectOutputStream.writeObject(SerializableSingleton.getInstance());
            File serializable = new File("serializable");
            ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(serializable));
            SerializableSingleton serializableSingleton = (SerializableSingleton) inputStream.readObject();
            System.out.println(serializableSingleton == SerializableSingleton.getInstance());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}