单例模式的创建与破坏

 双重锁懒汉式

/**
 * 双重锁 懒汉式
 */
public class LazySingletonUp {
    private static volatile LazySingletonUp lazySingletonUp;
    private LazySingletonUp(){}
    public static LazySingletonUp getInstance(){
        if (lazySingletonUp==null){
            synchronized (LazySingletonUp.class){
                if (lazySingletonUp==null){
                    lazySingletonUp=new LazySingletonUp();
                }
            }
        }
       return lazySingletonUp;
    }
}

 内部类实现单例模式  定义flag  简单防止反射破坏单例

/**
 * 内部类模式
 */
public class InnerClassSingle implements Serializable {
    private static boolean flag=false;
    private InnerClassSingle(){
        synchronized (this){
            if (flag){
                throw new RuntimeException("不能创建多个对象");
            }
        }
        flag=true;
    };
    private static class Instance{
        private static final InnerClassSingle INSTANCE=new InnerClassSingle();
    }
    public static InnerClassSingle getInnerClassSingle(){
        return Instance.INSTANCE;
    }
}

枚举单例模式

/**
 * 枚举类单例模式
 */
public enum EnumSingle {
    INSTANCE;
}

饿汉式单例模式

/**
 * 饿汉式
 */
public class Singleton1 implements Serializable {
    private static final Singleton1 singleton1=new Singleton1();
    private Singleton1(){
    };
    public static Singleton1 getSingleton1() {
        return singleton1;
    }
}

序列化破坏单例模式，单例对象要实现序列化

  @org.junit.Test
    public void breakSingleWrite() throws IOException {
        LazySingleton singleton = LazySingleton.getLazySingleton();
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("C://Users//Dsmash//Desktop//new.txt"));
        outputStream.writeObject(singleton);
        outputStream.close();
    } 

 @org.junit.Test
    public void breakSingleRead() throws IOException, ClassNotFoundException {
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("C://Users//Dsmash//Desktop//new.txt"));
        LazySingleton o = (LazySingleton) inputStream.readObject();
        System.out.println(o);
        inputStream.close();
    }

反射破坏单例模式

   @org.junit.Test
    public void breakReflect() throws Exception {
        InnerClassSingle singleton1 = InnerClassSingle.getInnerClassSingle();
        Class clazz = singleton1.getClass();
        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        InnerClassSingle o = (InnerClassSingle) constructor.newInstance();
        InnerClassSingle o1 = (InnerClassSingle) constructor.newInstance();
        System.out.println(o == o1);

    }

饿汉式静态代码块设计

/**
 * 饿汉式静态代码块
 */
public class Singleton2 {
    private static  Singleton2 singleton2;
    static {
        singleton2=new Singleton2();
    }
    private Singleton2(){};

    public static Singleton2 getSingleton2() {
        return singleton2;
    }
}