枚举实现单例模式

1.引言

单元素的枚举类型已经成为实现Singleton的最佳方法
                      -- 出自 《effective java》

2.单例模式的特点

• 单例模式三个主要特点：
  1、构造方法私有化；
  2、实例化的变量引用私有化；
  3、获取实例的方法共有。

3. 常用的单例模式

1.单例的饿汉模式

 1   public class Singleton {
 2     /*
 3      * 利用静态变量来记录Singleton的唯一实例
 4      * 直接初始化静态变量，这样就可以确保线程安全了
 5      */
 6     private static Singleton uniqueInstance = new Singleton();
 7
 8     /*
 9      * 构造器私有化，只有Singleton类内才可以调用构造器
10      */
11     private Singleton(){
12
13     }
14
15     public static Singleton getInstance(){
16         return uniqueInstance;
17     }
18
19 }

2.懒汉的双重加锁机制

 1 public class Singleton {
 2     /*
 3      * 利用静态变量来记录Singleton的唯一实例
 4      * volatile 关键字确保：当uniqueInstance变量被初始化成Singleton实例时，
 5      * 多个线程正确地处理uniqueInstance变量
 6      *
 7      */
 8     private volatile static Singleton uniqueInstance;
 9
10     /*
11      * 构造器私有化，只有Singleton类内才可以调用构造器
12      */
13     private Singleton(){
14
15     }
16
17     /*
18      *
19      * 检查实例，如果不存在，就进入同步区域
20      */
21     public static Singleton getInstance(){
22         if(uniqueInstance == null){
23             synchronized(Singleton.class){    //进入同步区域
24                 if(uniqueInstance == null){     //在检查一次，如果为null，则创建
25                     uniqueInstance  = new Singleton();
26                 }
27             }
28         }
29
30         return uniqueInstance;
31     }
32
33 }

3.静态内部类

1public class Singleton {    
2    private static class LazyHolder {    
3       private static final Singleton INSTANCE = new Singleton();    
4    }    
5    private Singleton (){}    
6    public static final Singleton getInstance() {    
7       return LazyHolder.INSTANCE;    
8    }    
9}

4.为什么使用单例

4.1 私有化构造器并不保存

《effective java》中只简单的提了几句话：“享有特权的客户端可以借助AccessibleObject.setAccessible方法，通过反射机制调用私有构造器。如果需要低于这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。

4.2序列化问题

任何一个readObject方法，不管是显式的还是默认的，它都会返回一个新建的实例，这个新建的实例不同于该类初始化时创建的实例。”当然，这个问题也是可以解决的，想详细了解的同学可以翻看《effective java》第77条：对于实例控制，枚举类型优于readResolve

4.3 枚举单例示例

1public enum  EnumSingleton {
2    INSTANCE;
3    public EnumSingleton getInstance(){
4        return INSTANCE;
5    }
6}

public class User {
    //私有化构造函数
    private User(){ }
 
    //定义一个静态枚举类
    static enum SingletonEnum{
        //创建一个枚举对象，该对象天生为单例
        INSTANCE;
        private User user;
        //私有化枚举的构造函数
        private SingletonEnum(){
            user=new User();
        }
        public User getInstnce(){
            return user;
        }
    }
 
    //对外暴露一个获取User对象的静态方法
    public static User getInstance(){
        return SingletonEnum.INSTANCE.getInstnce();
    }
}

public class Test {
    public static void main(String [] args){
        System.out.println(User.getInstance());
        System.out.println(User.getInstance());
        System.out.println(User.getInstance()==User.getInstance());
    }
}

结果为true

以上代码看起来已经是ok了，其实不是，可能还存在反射攻击或者反序列化攻击

最终版

public enum Singleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("doSomething");
    }

}
调用方法：

public class Main {

    public static void main(String[] args) {
        Singleton.INSTANCE.doSomething();
    }

}

直接通过Singleton.INSTANCE.doSomething()的方式调用即可。方便、简洁又安全。

5.总结

至此，相信大家应该能明白了为什么Joshua Bloch说的“单元素的枚举类型已经成为实现Singleton的最佳方法”了吧。