Java设计模式之单例模式

单例模式

　　主要作用：为系统生成唯一的一个实例（对象），永久驻留在内存中，减少了系统的资源开销。

常用的实现方式：

1、饿汉式

优点：线程安全、调用效率高

缺点：不能延时加载

代码：

public class SingletonDemo01 {
    //类初始化时，立即加载这个对象（无延时加载优势），加载类时是天然线程安全的
    private static SingletonDemo01 instance = new SingletonDemo01();

    //私有构造方法
    private SingletonDemo01() {}

    //加载类时是天然线程安全的，不需要同步，调用效率高
    public static SingletonDemo01 getInstance() {
        return instance;
    }

}

2、懒汉式

优点：线程安全、可延时加载

缺点：调用效率不高（每次调用都得同步，并发效率低）

代码：

public class SingletonDemo02 {
    //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）
    private static SingletonDemo02 instance;

    //私有化构造器
    private SingletonDemo02(){
    }

    //获取实例方法，synchronized进行同步，调用效率低
    public static synchronized SingletonDemo02 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo02();
        }
        return instance;
    }
}

3、静态内部类式

优点：线程安全、调用效率高、可延时加载，兼具了饿汉式和懒汉式的优点。

缺点：

代码：

public class SingletonDemo03 {
    //静态内部类，，只有调用getInstance方法时才会进行加载（延时加载）
    private static class InnerClass {
        //static final修饰instance，保证实例在内存中唯一（线程安全）
        private static final SingletonDemo03 instance = new SingletonDemo03();
    }

    //私有构造器
    private SingletonDemo03() {
    }

    //获取实例方法
    public static SingletonDemo03 getInstance() {
        return InnerClass.instance;
    }

}

4、枚举式

优点：基于JVM底层实现，天然单例，线程安全、调用效率高

缺点：不能延时加载

代码：

public enum  SingletonDemo04 {

    //该枚举元素本身就是单例的
    INSTANCE;
}

 

代码测试

public class Main {
    public static void main(String[] args) {
        //饿汉式创建的对象都是同一个对象
        SingletonDemo01 instance1 = SingletonDemo01.getInstance();
        SingletonDemo01 instance2 = SingletonDemo01.getInstance();
        System.out.println("饿汉式创建的2个实例是同一个对象？" + (instance1 == instance2));

        //懒汉式创建的对象都是同一个对象
        SingletonDemo02 instance3 = SingletonDemo02.getInstance();
        SingletonDemo02 instance4 = SingletonDemo02.getInstance();
        System.out.println("懒汉式创建的2个实例是同一个对象？" + (instance3 == instance4));

        //静态内部类创建的对象都是同一个对象
        SingletonDemo03 instance5 = SingletonDemo03.getInstance();
        SingletonDemo03 instance6 = SingletonDemo03.getInstance();
        System.out.println("静态内部类方式创建的2个实例是同一个对象？"+ (instance5 == instance6));

        //枚举式创建的对象都是同一个对象
        SingletonDemo04 instance7 = SingletonDemo04.INSTANCE;
        SingletonDemo04 instance8 = SingletonDemo04.INSTANCE;
        System.out.println("枚举式创建的2个实例是同一个对象？"+ (instance7 == instance8));

    }
}

输出结果：

饿汉式创建的2个实例是同一个对象？true
懒汉式创建的2个实例是同一个对象？true
静态内部类方式创建的2个实例是同一个对象？true
枚举式创建的2个实例是同一个对象？true

总结

当实例化对象非常占用系统资源且需要延时加载时，推荐使用懒汉式、静态内部类式（优于懒汉式）；

当实例化对象占用系统资源小时且要立即加载时，推荐使用饿汉式、枚举式（优于饿汉式）。

 扩展

单例模式中的枚举式基于JVM底层实现，是天然线程安全的，但是其他创建单例的方法用反射和反序列化的手段是可以破解的（可以创建多个不同的对象）。

这里以饿汉式为例：

未特殊处理的饿汉式代码：

public class SingletonDemo05 implements Serializable{
    //类初始化时，立即加载这个对象（无延时加载优势），加载类时是天然线程安全的
    private static SingletonDemo05 instance = new SingletonDemo05();

    //私有构造方法
    private SingletonDemo05() {}

    //加载类时是天然线程安全的，不需要同步，调用效率高
    public static SingletonDemo05 getInstance() {
        return instance;
    }

}

反射、反序列破解代码：

public class Main2 {
    public static void main(String[] args) throws Exception{
        SingletonDemo05 s1 = SingletonDemo05.getInstance();
        SingletonDemo05 s2 = SingletonDemo05.getInstance();
        System.out.println("饿汉式创建的2个实例是同一个对象？" + (s1 == s2));

        //反射方式破解单例
        Class<SingletonDemo05> clazz = (Class<SingletonDemo05>) Class.forName("com.led.singleton.SingletonDemo05");
        Constructor<SingletonDemo05> constructor = clazz.getDeclaredConstructor(null);
        //使用下面的方法才能访问私有方法
        constructor.setAccessible(true);
        SingletonDemo05 s3 = constructor.newInstance();
        System.out.println("反射生成的对象和正常生成的是同一个对象吗？" + (s1 == s3));//false

        //反序列化方式破解单例
        //1、先序列化到本地磁盘（SingletonDemo05需要实现Serializable接口）
        FileOutputStream fos = new FileOutputStream("D:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //Write the specified object to the ObjectOutputStream
        oos.writeObject(s1);
        if (oos != null) {
            oos.close();
        }
        if (fos != null) {
            fos.close();
        }
        //2、从磁盘反序列化到内存
        FileInputStream fis = new FileInputStream("D:/a.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        SingletonDemo05 s4 = (SingletonDemo05) ois.readObject();
        if (ois != null) {
            ois.close();
        }
        if (fis != null) {
            fis.close();
        }
        System.out.println("正常创建的和反序列化生成的是同一个对象？" + (s1 == s4));//false


    }
}

控制台输出：

饿汉式创建的2个实例是同一个对象？true
反射生成的对象和非反射生成的是同一个对象吗？false
正常创建的和反序列化生成的是同一个对象？false

由此可见，不对饿汉式代码进行特殊处理，使用反射和反序列方法会破坏单例性。

对反射的特殊处理：

对饿汉式类中的构造方法进行修改，当已经有实例时，抛出异常，防止创建多个不同实例

//私有构造方法
    private SingletonDemo05() {
        if (instance != null) {
            throw new RuntimeException("实例已存在");
        }
    }

控制台输出：

饿汉式创建的2个实例是同一个对象？true
Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at com.led.singleton.Main2.main(Main2.java:25)
Caused by: java.lang.RuntimeException: 实例已存在
    at com.led.singleton.SingletonDemo05.<init>(SingletonDemo05.java:18)
    ... 5 more

对反序列化的特殊处理：

在饿汉式类中通过定义readResolve()防止获得不同对象

//通过定义readResolve()防止获得不同对象
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }

控制台输出：

正常创建的和反序列化生成的是同一个对象？true

 

特殊处理的饿汉式代码：

public class SingletonDemo05 implements Serializable{
    //类初始化时，立即加载这个对象（无延时加载优势），加载类时是天然线程安全的
    private static SingletonDemo05 instance = new SingletonDemo05();

    //私有构造方法
    private SingletonDemo05() {
　　　　 //通过抛出异常，防止反射通过构造器创建多个实例
        if (instance != null) {
            throw new RuntimeException("实例已存在");
        }
    }

    //加载类时是天然线程安全的，不需要同步，调用效率高
    public static SingletonDemo05 getInstance() {
        return instance;
    }

    //通过定义readResolve()方法，防止通过反序列化方式创建多个实例
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }

}