设计模式(七)——单例模式

曾经终败给现在 2022-05-19 01:46 156阅读 0赞

### **一、单例模式** ###

**1、介绍**

*  核心作用  
      
    — 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
 *  常用场景：  
      
    — Windows的任务管理器就是一个典型的单例模式  
    — Windows中的回收站也是一个单例模式，整个系统运行过程中，回收站一直维持着仅有的一个实例。  
    — 项目中，读取配置文件的时候，一般也只有一个对象，没有必要每次使用配置文件的时候都去new一个对象。  
    — 网站的计数器一般也是采用单例模式，否则难以同步。  
    — 应用程序的日志应用，一般也是采用单例模式实现，这一般是由于共享日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。  
    — 数据库连接池的设计一般也是采用单例模式，因为数据库连接池是一种数据库资源。  
    — 操作系统的文件系统，也是一个大的单例模式，一个操作系统只有一个文件系统。  
    — Application也是一个单例模式。  
    — 在Spring中，每个bean默认就是单例的，这样做的优点是Spring容器可以管理。  
    — SpringMVC框架中，控制器对象也是单例。  
     
 *  单例模式的优点  
    — 由于单例模式只生成一个实例，减少了系统的性能开销，当一个对象产生需要比较多的资源的时候，如读取配置、产生其他依赖对象时，则可以通过在应用启动的时候直接产生一个单例对象，然后永久驻留在内存方式来解决。  
    —单例模式可以在系统设置全局的访问点，优化共享资源的访问，例如可以设计一个单例类，负责所有数据表的映射。
 *  常用的五种单例模式的实现方式：  
      
    — 主要：  
    1）饿汉式（线程安全，调用效率高。但是，不能延时加载。）  
    2）懒汉式（线程安全，调用效率不高。但是可以延迟加载。）  
    — 其他：  
    3）双重检测锁式（由于JVM底部内层模型原因，偶尔会出问题。不建议使用）  
    4）静态内部类式（线程安全，调用效率不高。但是可以延时加载。）  
    5）枚举单例（线程安全，调用效率高，不能延时加载。）

**2）饿汉式单例模式**

/**
     * @author chenpeng
     * @date 2018/7/18 22:22
     * 饿汉式单例模式
     *  加载类的时候就实例化静态属性
     */
    public class Singleton {
        /**
         * 1、实例化一个静态属性，类初始化的时候立即加载这个对象（没有延时加载的优势）
         * 由于加载类时天然是线程安全的，所以是线程安全的
         */
        private static Singleton newInstance = new Singleton();
        //2、私有构造方法
        public Singleton() { }
    
        /**
         * 3、开放的访问方法
         * 方法没有同步，效率高
         * @return
         */
        public static Singleton getNewInstance() {
            return newInstance;
        }
    }

*  饿汉式单例模式代码中，static变量会在类加载的时候初始化，此时也不会设计多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。
 *  问题：如果只是加载本类，而不是要调用getInstance( )方法，甚至永远没有调用，则会造成资源浪。

**3）懒汉式单例模式（单例对象延迟加载）**

/**
     * @author chenpeng
     * @date 2018/7/20 23:42
     * 懒汉式单例模式
     */
    public class SingletonLazy {
        /**1、定义一个变量，但是不实例化*/
        private static SingletonLazy newInstance;
        /**2、私有构造器*/
        public SingletonLazy() {
        }
        /**
         * 3、提供外部访问方法
         * 需要提供同步方法，防止并发问题
         */
        public static synchronized SingletonLazy getNewInstance() {
            if (newInstance==null){
                newInstance = new SingletonLazy();
            }
            return newInstance;
        }
    }

*  要点  
    — lazy load！延迟加载，懒加载，真正用的时候才加载！
 *  问题：  
    — 资源利用率高。但是每次调用getNewInstance( )方法的时候都要同步，并发效率低。

**4）双重检查锁实现单例模式**

/**
     * @author chenpeng
     * @date 2018/7/20 23:42
     * 双重检查锁单例模式
     */
    public class SingletonLazy {
        /**1、定义一个变量，但是不初始化（真正用的时候再加载）*/
        private static SingletonLazy newInstance;
        /**2、私有构造器*/
        public SingletonLazy() {
        }
        /**
         * 3、提供外部访问方法
         */
        public static SingletonLazy getNewInstance() {
            if (newInstance==null){
                synchronized (SingletonLazy.class){
                    SingletonLazy sl = newInstance;
                    if (sl == null){
                        synchronized (SingletonLazy.class) {
                            newInstance = new SingletonLazy();
                        }
                    }
    
                }
            }
            return newInstance;
        }
    }

*  问题：由于编译器优化原因和JVM底层内部模型原因，偶尔会出现问题。不建议使用。

**5）静态内部类实现单例模式**

/**
     * @author chenpeng
     * @date 2018/7/18 22:22
     * 静态内部类实现单例模式
     *  这种方式：线程安全、调用效率高，并实现了延时加载。
     */
    public class Singleton {
        /**
         * 1、静态内部类，在其中实例化一个静态属性
         * 由于加载类时天然是线程安全的，所以是线程安全的
         * 初始化的时候并不会直接初始化静态内部类，只有调用getNewInstance方法的时候才会加载
         * 所以能够实现延迟加载
         */
        public static class SingletonClassInstance{
            private static final Singleton newInstance = new Singleton();
        }
    
        //2、私有构造方法
        public Singleton() { }
    
        /**
         * 3、开放的访问方法
         * 方法没有同步，效率高
         * @return
         */
        public static Singleton getNewInstance() {
            return SingletonClassInstance.newInstance;
        }
    }

*  要点：  
    — 外部类没有static属性，则不会像饿汉式那样立即加载对象。  
    — 只有真正调用 getNewInstance 方法才会加载静态内部类。加载类时是线程安全的。newInstance 是static final 类型的，保证了内存中只有一个这样的实例存在，而且只能被赋值一次，从而保证了线程的安全性。  
    —兼具了并发高效调用和延迟加载的优势。

**6）枚举实现单例模式**

/**
     * @author chenpeng
     * @date 2018/7/22 23:11
     * 枚举实现单例模式
     * 没有懒加载模式
     */
    public enum EnumSingleton {
        //定义一个枚举的元素，这个枚举元素本身就是单例对象
        INSTANCE;
    
        //单例添加自己需要的操作
        public void singletonOperation(){
            //功能处理
        }
    }

*  优点  
    — 实现简单  
    — 枚举本身就是单例模式。由于JVM从根本上提供保障！避免了通过反射和反序列化的漏洞！
 *  缺点：无延迟加载

**7）使用选择**

*  单列对象 占用资源少，不需要延迟加载  
    枚举式  好于  饿汉式
 *  单例对象 占用资源较大，需要延时加载  
    静态内部类式  好于 懒汉式

### 二、问题 ###

1、反射可以破解上面几种（不包括枚举）实现方式！（可以在构造方法中手动抛出异常控制）

2、反序列化可以破击上面几种（不包括枚举式）实现方式！

可以通过定义readResolve( )防止获得不同的对象。反序列化时，如果对象所在类定义了readResolve( )，