设计模式之单例模式(创建、单例破坏、防止破坏)-阿里云开发者社区

单例模式是23种设计模式之一，也是学习设计模式遇到的第一个设计模式。

意义：在实际开发中，会有很多通用类，比如获取数据源的类，假如在使用这些类的时候，每用一次就创建一个新的实例，这样就会创建很多实例，实际上这些实例做的作用都是一样的。要想避免这种无用的创建实例，这里就需要用到单例模式。

类型：创建型模式

实现方式：1.构造器私有化 2.在类内部创建好一个实例 3.提供一个方法来获取实例

使用方式：获取该类的实例时，使用提供的方法来获取

接下来从三个方面来介绍单例模式

单例模式创建

1.饿汉式

含义：饿汉式就是犹如它的名字一样，很饿，所以提前准备好食物(实例)。

/**
 * 1.饿汉式
 */
public class Singleton1 {
    //1.构造器私有化
    private Singleton1() {
    }
    //2.本类内部创建对象实例
    private final static Singleton1 singleton1 = new Singleton1();
    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton1 getInstance() {
        return singleton1;
    }
}

优点：这种写法非常的简练，并且线程安全。

缺点：假如这个类不会被使用到，但是在类加载的时候就会创建一个实例，造成了内存浪费。

2.懒汉式

含义：很懒，一开始不会去创建，等你到使用的时候再去创建。

/**
 * 2.懒汉式(线程不安全)
 */
public class Singleton2 {
    //1.构造器私有化
    private Singleton2() {
    }
    //2.本类内部创建对象实例
    private static Singleton2 singleton2;
    //3.提供一个获取实例的方法，但是在第一次使用的时候再去实例化(存在线程安全问题)
    public static Singleton2 getInstance() {
        if (singleton2 == null) {
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

但是这种存在线程安全问题，当多个线程调用 getInstance()方法时，有可能出现线程a执行到 singleton2 = new Singleton2(); 这行时，这时候失去cpu执行权，b线程开始执行getInstance() 方法，成功创建了一个实例，这时候a线程获取到cpu执行权，继续执行 singleton2 = new Singleton2(); 就会造成获取到两个不同的实例。

那么怎么规避这种情况那，答案就是加锁，但是仅仅的加锁还是不完美的

/**
 * 3.懒汉式(双重检查，线程安全)
 */
public class Singleton3 {
    //1.构造器私有化
    private Singleton3() {
    }
    //2.本类内部创建对象实例
    private static volatile Singleton3 singleton3;
    //3.提供一个获取实例的方法，但是在第一次使用的时候再去实例化
    public static Singleton3 getInstance() {
        if (singleton3 == null) {
            synchronized (Singleton3.class) {
                if (singleton3 == null) {
                    singleton3 = new Singleton3();
                }
            }
        }
        return singleton3;
    }
}

这里提供了一种双重检查的方法来使懒汉式变成线程安全的方式。

为什么是双重检查，而不是下面这种写法呢？

这是因为如果是下面这种写法，再每一次获取实例对象的时候，所有线程都会去竞争锁，导致额外的开销。实际上线程安全问题只存在第一次创建对象的时候。在synchronized外层套一层判断就可以规避对象创建完成之后，线程竞争锁的问题，提高了效率。

public static Singleton3 getInstance() {
    synchronized (Singleton3.class) {
        if (singleton3 == null) {
            singleton3 = new Singleton3();
        }
    }
    return singleton3;
}

为什么要使用volatile关键字？

这是因为 singleton3 = new Singleton3(); 这一步并不是原子操作，别看这是一行代码，在底层它被分成了三步操作：

1.分配一部分空间用于创建对象

2.在分配好的空间创建对象

3.将创建好的对象指向变量，在这里变量是singleton3

cpu在操作时为了提高效率会出现指令重排的操作，也就是把这三步进行乱序。假如说步骤变成了 1、3、2。那么就会导致当a线程执行到第2步(执行顺序是132)的时候失去了操作权，b线程开始执行（由于a线程没有执行第2步就把空间指向了变量），发现singleton3指向的空间不是null，但是实际上此空间并没有实例，那么b线程使用该对象时候就会报错。

使用了volatile关键字就会禁止指令重排。

优点：进行了懒加载

缺点：编写复杂，要考虑线程安全

3.静态内部类

/**
 * 4.静态内部类
 */
public class Singleton4 {
    //1.创建静态内部类来声名实例对象
    private static class InnerSingleton {
        private static final Singleton4 SINGLETON_4 = new Singleton4();
    }
    //2.构造器私有化
    private Singleton4() {
    }
    //3.提供一个获取实例的方法
    public static Singleton4 getInstance() {
        return InnerSingleton.SINGLETON_4;
    }
}

优点：也是懒加载

4.枚举

/**
 * 5.枚举
 */
public enum Singleton5 {
    INSTANCE;
}

优点：无法使用序列化和反射破坏单例

破坏单例模式

在知道怎么编写单例模式之后，实际上单例模式是可以进行破坏的，这里介绍三种方式：

1.反射

这里通过反射来破坏单例模式，虽然有很多方式在构造器中预防单例模式被破坏，但是道高一尺魔高一丈，总有办法进行破坏。

/**
 * 反射破坏单例模式
 */
public class ReflectDestroy {
    public static void main(String[] args) throws Exception {
        //1。获取Singleton1的无参构造方法
        Constructor<Singleton1> constructor = Singleton1.class.getDeclaredConstructor();
        //2.接触private的封装
        constructor.setAccessible(true);
        //3.通过反射和单例模式创建两个对象，进行比较
        Singleton1 instance1 = constructor.newInstance();
        Singleton1 instance2 = Singleton1.getInstance();
        //4.结果为false，说明两个对象不是一个对象，单例模式被破坏了
        System.out.println(instance1 == instance2);
    }
}

2.序列化

首先实现Serializable接口才可以进行序列化

/**
 * 1.饿汉式
 */
public class Singleton1 implements Serializable {
    //1.构造器私有化
    private Singleton1() {
    }
    //2.本类内部创建对象实例
    private final static Singleton1 singleton1 = new Singleton1();
    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton1 getInstance() {
        return singleton1;
    }
}

然后进行测试

public class SerializableDestroy {
    public static void main(String[] args) throws Exception {
        //1.获取实例
        Singleton1 instance1 = Singleton1.getInstance();
        //2.使用输出流保存该对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("instance"));
        out.writeObject(instance1);
        //3.使用输入流读取对象
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("instance"));
        Singleton1 instance2 = (Singleton1) in.readObject();
        //4.发现结果为false，单例被破坏
        System.out.println(instance1 == instance2);
    }
}

这里发现单例被破坏，但是可以预防。

3.克隆

首先要实现Cloneable接口

public class Singleton6 implements Cloneable{
    private Singleton6() {
    }
    private final static Singleton6 singleton6 = new Singleton6();
    public static Singleton6 getInstance() {
        return singleton6;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

测试

public class CloneDestroy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Singleton6 instance1 = Singleton6.getInstance();
        Singleton6 instance2 = (Singleton6) instance1.clone();
        System.out.println(instance1 == instance2);
    }
}

发现单例被破坏，那么如何防止单例被破坏那，请看下一个章节。

如何防止单例模式被破坏

这里我们从破坏单例模式的两个方面进行讲解

1.反射

如果是枚举类，那么就不可以使用反射进行破坏

public class ReflectEnumDestroy {
    public static void main(String[] args) throws Exception {
        //1.获取枚举类的构造方法
        Constructor<Singleton5> constructor = Singleton5.class.getDeclaredConstructor(String.class, int.class);
        //2.解除封装
        constructor.setAccessible(true);
        //3.创建对象，此步骤会报错：Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        Singleton5 instance = constructor.newInstance("INSTANCE", 0);
    }
}

首先说一下第一步，为什么获取构造函数要两个参数。枚举类实际上就是一个类实现Enum接口，在Enum接口中可以看到该构造方法

那第三步为什么会报错那，可以点进 newInstance(); 这个方法

这里可以看到在jdk中就定义了不准枚举类进行反射，自然而然枚举类不可以反射创建对象。

2.序列化

又是如何在序列化中保证单例那？

其实在单例类中加一个方法即可

/**
 * 1.饿汉式
 */
public class Singleton1 implements Serializable {
    //1.构造器私有化
    private Singleton1() {
    }
    //2.本类内部创建对象实例
    private final static Singleton1 singleton1 = new Singleton1();
    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton1 getInstance() {
        return singleton1;
    }
    //4.新加入的方法，防止序列化破坏单例
    private Object readResolve() {
        return singleton1;
    }
}

然后进行测试

public class SerializableDestroy {
    public static void main(String[] args) throws Exception {
        //1.获取实例
        Singleton1 instance1 = Singleton1.getInstance();
        //2.使用输出流保存该对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("instance"));
        out.writeObject(instance1);
        //3.使用输入流读取对象
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("instance"));
        Singleton1 instance2 = (Singleton1) in.readObject();
        //4.发现结果为true，是单例的
        System.out.println(instance1 == instance2);
    }
}

为什么这个方法加入就可以保证单例那？

在ObjectInputStream类中可以找到答案

可以从 Singleton1 instance2 = (Singleton1) in.readObject(); 这一行的readObject()方法进入查看

如果单例类中有readResolve()方法，那么就会调用这个方法获取对象，保持单例。

枚举类本身就实现了序列化接口，直接进行序列化就可以

public class SerializableEnumDestroy {
    public static void main(String[] args) throws Exception {
        Singleton5 instance1 = Singleton5.INSTANCE;
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("instance"));
        out.writeObject(instance1);
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("instance"));
        Singleton5 instance2 = (Singleton5) in.readObject();
        //结果为true，是单例的
        System.out.println(instance1 == instance2);
    }
}

枚举类没有readResolve()方法但是也可以保持单例，这是因为枚举的实例会保存在一个map中，实际读取的时候会从map中读取保证单例。

可以说枚举的特性用来做单例最为合适，后期整理到框架，也会结合框架来丰富单例模式。

设计模式之单例模式(创建、单例破坏、防止破坏)

单例模式创建

1.饿汉式

2.懒汉式

3.静态内部类

4.枚举

破坏单例模式

1.反射

2.序列化

3.克隆

如何防止单例模式被破坏

1.反射

2.序列化

热门文章

最新文章

相关电子书