java 单例实现方式对比

今天药忘吃喽~ 2021-06-24 13:58 384阅读 0赞

单例模式是一种广泛使用的设计模式，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间（比如spring管理的无状态bean）；还能够避免由于操作多个实例导致的逻辑错误；在应用的整个生命周期内，只有一个对象，起到了全局统一管理控制的作用。

接下来，我们看一下如何在java中创建单例对象。

**1、恶汉加载方式：**

public class Singleton {  
        private static Singleton instance = new Singleton();  
        private Singleton (){}  
        public static Singleton getInstance() {  
        	return instance;  
        }  
    } 
    //或者
    public class Singleton {  
        private static Singleton instance = null;  
        static {  
          instance = new Singleton();  
        }  
        private Singleton (){}  
        public static Singleton getInstance() {  
        	return instance;  
        }  
    }

说明：这种方式基于static和classloder机制，确保了在类加载时创建了该类对象，同时通过private构造函数，保证了在其他类中无法通过new的方式创建对象。

**2、双重检验锁：**

public class Singleton {  
        private volatile static Singleton singleton;  //volatile修饰
        private Singleton (){}  
        public static Singleton getSingleton() {  
    	    if (singleton == null) {  
    	        synchronized (Singleton.class) {  
    	        	// 注意此处还得有次判空~
    		        if (singleton == null) {  
    		            singleton = new Singleton();  
    		        }  
    	        }  
    	    }  
    	    return singleton;  
        }  
    }

说明：这是一种懒汉模式（懒加载功能）。

**3、静态内部类：**

public class Singleton {  
    	// 静态内部类
        private static class SingletonHolder {  
        	private static final Singleton INSTANCE = new Singleton();  
        }  
        private Singleton (){}  
    	
        public static final Singleton getInstance() {  
        	return SingletonHolder.INSTANCE;  
        }  
    }

说明：这也是一种懒汉模式，利用了静态内部类和外部类没有关联这一特点，只有调用getInstance方法时才去加载静态内部类，并且在静态内部类中有一个static的成员对象，确保了唯一性。

**4、枚举方式：**

public enum Singleton {
        INSTANCE;
        
        //属性方法
        private String str = "test";
        public void say() {
            System.out.println("hello" + str);
        }
    }
    
    //使用时
    Singleton.INSTANCE.say();

说明：枚举编译后也是一个类，所以可以像类中定义的变量、方法一样，在枚举中定义。

这种方式是Effective Java作者Josh Bloch提倡的方式，是最安全的一种单例模式。为什么说是最安全的？我们先来看前三种实现单例的方式，其特点是：

*  静态化实例对象
 *  私有化构造方法，禁止通过构造方法创建实例
 *  提供一个公共的静态方法，用来返回唯一实例

问题就出在私有化构造方法，无法抵御反射调用的攻击；此外，对于对象序列化、反序列化操作，jdk也会创建对象。那么接下来，测试一下是否安全。

4.1）我们以最常见的恶汉模式单例来测试：

public class Singleton implements Serializable {  
        private static Singleton instance = new Singleton();  
        private Singleton (){}  
        public static Singleton getInstance() {  
        	return instance;  
        }  
    }
    
    public class Main {
    
        public static void main(String[] args) throws Exception {
            Singleton s = Singleton.getInstance();
    
            // 拿到所有的构造函数，包括非public的
            Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            // 使用空构造函数new一个实例。即使它是private的~~~
            Singleton sReflection = constructor.newInstance();
    
            System.out.println(s); //com.fsx.bean.Singleton@1f32e575
            System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
            System.out.println(s == sReflection); // false
        }
    }

输出：

com.fsx.bean.Singleton@1f32e575
    com.fsx.bean.Singleton@279f2327
    false

通过反射，竟然给所谓的单例创建出了一个新的实例对象。所以这种方式也还是存在不安全因素的。怎么破？其实Joshua Bloch说了：可以在构造函数在被第二次调用的时候抛出异常。具体示例代码，可以参考枚举实现的源码。

再看看它的序列化、反序列时会不会有问题（单例底层并不是反射）。如下：

public class Main {
    
        public static void main(String[] args) throws Exception {
            Singleton s = Singleton.getInstance();
    
            byte[] serialize = SerializationUtils.serialize(s);
            Object deserialize = SerializationUtils.deserialize(serialize);
    
    
            System.out.println(s);
            System.out.println(deserialize);
            System.out.println(s == deserialize);
    
        }
    }

输出：

com.fsx.bean.Singleton@452b3a41
    com.fsx.bean.Singleton@6193b845
    false

可以看出，序列化前后两个对象并不相等。所以它序列化也是不安全的。

4.2）以枚举单例测试：

public enum EnumSingleton {
        INSTANCE;    
    }

1）反射攻击：

public class Main {
    
        public static void main(String[] args) throws Exception {
            EnumSingleton s = EnumSingleton.INSTANCE;
    
            // 拿到所有的构造函数，包括非public的
            Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            // 使用空构造函数new一个实例。即使它是private的~~~
            EnumSingleton sReflection = constructor.newInstance();
    
            System.out.println(s); //com.fsx.bean.Singleton@1f32e575
            System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
            System.out.println(s == sReflection); // false
        }
    
    }

输出：

Exception in thread "main" java.lang.NoSuchMethodException: com.fsx.bean.EnumSingleton.<init>()
    	at java.lang.Class.getConstructor0(Class.java:3082)
    	at java.lang.Class.getDeclaredConstructor(Class.java:2178)
    	at com.fsx.maintest.Main.main(Main.java:19)

这个看起来是因为没有空的构造函数导致的，还并不能下定义说防御了反射攻击。那它有什么构造函数呢，可以看它的父类Enum类：

// @since   1.5  它是所有Enum类的父类，是个抽象类
    public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
    	// 这是它的唯一构造函数，接收两个参数（若没有自己额外指定构造函数的话~）
        protected Enum(String name, int ordinal) {
            this.name = name;
            this.ordinal = ordinal;
        }
        ...
    }

既然它有这个构造函数，那我们就先拿到这个构造函数再创建对象试试：

public class Main {
    
        public static void main(String[] args) throws Exception {
            EnumSingleton s = EnumSingleton.INSTANCE;
    
            // 拿到所有的构造函数，包括非public的
            Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);// 拿到有参的构造器
            constructor.setAccessible(true);
            // 使用空构造函数new一个实例。即使它是private的~~~
            System.out.println("拿到了构造器：" + constructor);
            EnumSingleton sReflection = constructor.newInstance("testInstance", 1);
    
            System.out.println(s); //com.fsx.bean.Singleton@1f32e575
            System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
            System.out.println(s == sReflection); // false
        }
    }

输出：

拿到了构造器：private com.fsx.bean.EnumSingleton(java.lang.String,int)
    Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    	at com.fsx.maintest.Main.main(Main.java:22)

第一句输出了，表示我们是成功拿到了构造器Constructor对象的，只是在执行newInstance时候报错了。并且也提示报错在Constructor的417行，看看Constructor的源码处：

public final class Constructor<T> extends Executable {
    	...
        public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    		...
            if ((clazz.getModifiers() & Modifier.ENUM) != 0)
                throw new IllegalArgumentException("Cannot reflectively create enum objects");
    		...
    	}
    	...
    }

主要是这一句：(clazz.getModifiers() & Modifier.ENUM) != 0。说明：反射在通过newInstance创建对象时，会检查该类\*\*是否ENUM修饰\*\*，如果是则抛出异常，反射失败，因此枚举类型对反射是绝对安全的。

2）反序列化攻击：

public class Main {
    
        public static void main(String[] args) {
            EnumSingleton s = EnumSingleton.INSTANCE;
    
            byte[] serialize = SerializationUtils.serialize(s);
            Object deserialize = SerializationUtils.deserialize(serialize);
            System.out.println(s == deserialize); //true
        }
    
    }

结果是：true。因此：枚举类型对序列化、反序列也是安全的。