java单列模式的几种实现方式

た入场券 2022-11-29 12:59 203阅读 0赞

单列模式（SIngleton pattern）是java中最基础的一种设计模式，他的作用是保证一个类仅有一个实例，并且提供一个访问它的全局访问点，避免重复创建对象，节省系统资源。以下通过五种方式来实现，可根据不同的场景选用。

## 一、饿汉式 ##

public class Singleton { 
        //类加载时就创建本类的对象
        private static Singleton instance = new Singleton();
        //构造器私有化，使外部不能通过new来创建对象
        private Singleton(){ }
        //外部可通过该方法来获取唯一实例
        public static Singleton getInstance(){ 
            return instance;
        }
    }

之所以称之为**饿汉式**，可以理解为：饿了，马上就要吃，在类加载的时候就创建对象，用时直接取就行。

缺点：在还不需要此类的实例的时候就已经创建好了，没有起到 lazy loading 的效果。

优点：简单、安全可靠

## 二、懒汉式 ##

##### 1、线程不安全 #####

public class Singleton { 
        //用静态变量来记录本类实例
        private static Singleton instance;
        //获取实例
        public static Singleton getInstance(){ 
            if(instance == null){ 
            	instance = new Singleton();
        	}
            return instance;
        }
        //构造器私有化
        private Singleton(){ }
      
    }

可以理解为：很懒、需要用时再创建，当一个对象使用频率不是很高、占用的内存特别大，饿汉式就明显不合适了，这时就需要懒汉式这种懒加载的思想，等到程序需要实例的时候再创建。上面这种实现方式是存在线不程安全问题，在并发获取实例的时候，可能会存在构建多个实例的情况，通过下面的改进可以实现线程安全：

##### 2、线程安全 #####

public class Singleton { 
        private static volatile Singleton instance;
        //构造器私有化，禁止外部通过new创建实例
        private Singleton(){ }
        
        public static Singleton getInstance(){ 
            if(instance == null){ 
                synchronized(Singleton.class){ 
                    if(instance == null){ 
                        instance = new Singleton();
                    }
                }
            }
            
            return instance;
        }
    }

与上面的相比，这里使用了**双重效验**的方式，对懒汉式线程安全化，通过加锁，可以保证同时只有一个线程走到第二个判空代码中去，这样保证了只创建 一个实例。这里还用到了volatile关键字来修饰singleton，其最关键的作用是防止指令重排。

## 三、静态内部类式 ##

通过这种静态内部类的方式实现的单例模式是线程安全的，静态的内部类在Singleton加载的时候是不会加载的。在调用getInstance时才会创建Singleton的实例，起到了懒加载的作用。

以上方式实现单例模式看起来已经完美，但是还会存在一些安全问题，即反射攻击、反序列化攻击，下面就通过这两种方式来获取新的实例，并验证原来的实列和新的实例是否是一个实例。

**反射获取新实例**

public class Singleton { 
        
        private static class SingletonHolder { 
            private static Singleton instance = new Singleton();
        }
        
        private Singleton(){ }
        
        public static Singleton getInstance(){ 
            return SingletonHolder.instance;
        }
    
        public static void main(String[] args) { 
    
                Singleton singleton = Singleton.getInstance();
                Constructor<Singleton> constructor;
                try { 
                    constructor = Singleton.class.getDeclaredConstructor();
                    constructor.setAccessible(true);
                    Singleton newSingleton = constructor.newInstance();
                    System.out.println(singleton == newSingleton);
                }catch (Exception e){ 
    
                }
    
            }
    }

![在这里插入图片描述][20200821131941233.PNG]  
通过结果可以看出这两个实例不是同一个实例，这和我们的单例模式不符。

除了反射获取还可以通过反序列化的方式获取到新的实例：

**反序列化方式获取新实例**

public class Singleton implements Serializable { 
        
        private static class SingletonHolder { 
            private static Singleton instance = new Singleton();
        }
        
        private Singleton(){ }
        
        public static Singleton getInstance(){ 
            return SingletonHolder.instance;
        }
        
        public static void main(String[] args) { 
    
            Singleton singleton = Singleton.getInstance();
    
            try { 
    
                ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream(new File("./Singleton.txt")));
                //把对象写入磁盘
                oos.writeObject(singleton);
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("./Singleton.txt")));
                //从磁盘中读取对象
                Singleton newSingleton = (Singleton)ois.readObject();
    			//比较
                System.out.println(singleton == newSingleton);
            } catch (IOException | ClassNotFoundException e) { 
                e.printStackTrace();
            }
        }
    }

![在这里插入图片描述][20200821132011403.PNG]  
和反射获取的结果是一样的，下面通过枚举的方式实现解决上面这两个问题。

## 四、枚举方式 ##

public enum EnumSingleton { 
        
        INSTANCE;
    
        private EnumSingleton(){ 
            System.out.println("init");
        }
    
        public void sayHello(){ 
            System.out.println("hello");
        }
    
        public static void main(String[] args) { 
            for (int i =0;i<5;i++){ 
                EnumSingleton.INSTANCE.sayHello();
            }
    
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70]  
结果可以看出实际只初始化了一次，这种方式也可以实现单例。利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单。

# 总结 #

以上通过了多中方式实现了单例模式，分析其的利弊，可根据场景选用。

[20200821131941233.PNG]: /images/20221124/7eb8f3e9c0c34b4493d865d90e4b7d27.png
[20200821132011403.PNG]: /images/20221124/0995a5d71ffc4f90af30f30c5d299717.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6cWFhYXNzcw_size_16_color_FFFFFF_t_70]: /images/20221124/e40abce9481d4da2b11ff2f4c9ba0b64.png