设计模式 ☞ 创建型模式之单例模式

妖狐艹你老母 2022-12-29 11:30 101阅读 0赞

## 1.1 简介 ##

### 1.1.1 概述 ###

单例(Singleton)模式的定义：是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。单例模式在现实生活中的应用也非常广泛，例如，早上进公司一看，呵！这不是部门经理嘛，还是那个味，还是昨天那个人，妥妥的单例。

![在这里插入图片描述][20201222144006346.png_pic_center]

### 1.1.2 优缺点 ###

单例模式的优点：  
 ① 单例模式可以保证内存里只有一个实例，减少了内存的开销。  
 ② 可以避免对资源的多重占用。  
 ③ 单例模式设置全局访问点，可以优化和共享资源的访问。

单例模式的缺点：  
 ① 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。  
 ② 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。  
 ③ 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

## 1.2 实现方式 ##

### 1.2.1 饿汉式（静态常量） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public class Singleton { 
    
        /** * 私有构造方法 */
        private Singleton() { };
    
        /** * 创建实例 */
        private static final Singleton INSTANCE = new Singleton();
    
        /** * 获取实例 * @return Singleton */
        public static Singleton getInstance() { 
            return INSTANCE;
        }
    }

这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法时装载，但是导致类装载的原因有很多种，因此不能确定有其他的方式导致类装载，这时候初始化 instance 就没有达到懒加载的效果，可能导致内存浪费。

### 1.2.2 饿汉式（静态代码块） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public class Singleton { 
    
        /** * 私有构造方法 */
        private Singleton() { };
    
        /** * 创建内部对象 */
        private static Singleton instance;
    
    
        /** * 在静态代码块中创建实例 */
        static { 
            instance = new Singleton();
        }
    
        /** * 获取实例 * @return Singleton */
        public static Singleton getInstance() { 
            return instance;
        }
    }

这种方式和第一种使用静态常量的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。

### 1.2.3 懒汉式（线程不安全） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public class Singleton { 
    
        /** * 私有构造方法 */
        private Singleton() { };
    
        /** * 创建内部对象 */
        private static Singleton instance;
    
        /** * 获取实例 * @return Singleton */
        public static Singleton getInstance() { 
            if (null == instance) { 
            	// 多个线程同时进入 if 判断中，会产生多个实例
                instance = new Singleton();
            }
            
            return instance;
        }
    }

虽然起到了懒加载的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了 if 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在实际开发中，不要使用这种方式。

### 1.2.4 懒汉式（同步方法） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public class Singleton { 
    
        /** * 私有构造方法 */
        private Singleton() { };
    
        /** * 创建内部对象 */
        private static Singleton instance;
    
        /** * 获取实例 * 使用 synchronized 关键字修饰方法，将其声明为同步方法 * @return Singleton */
        public static synchronized Singleton getInstance() { 
            if (null == instance) { 
                instance = new Singleton();
            }
    
            return instance;
        }
    }

虽然解决了线程安全问题，但是效率太低了，每个线程在想获得类的实例时候，执行 getlnstance 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低，在实际开发中，不推荐使用这种方式

### 1.2.5 懒汉式（同步代码块） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public class Singleton { 
    
        /** * 私有构造方法 */
        private Singleton() { };
    
        /** * 创建内部对象 */
        private static Singleton instance;
    
        /** * 获取实例 * @return Singleton */
        public static Singleton getInstance() { 
            if (null == instance) { 
                // 多个线程进入 if 中依然会出现问题，该种方式只是在前进道路的探索，无法使用
                synchronized (Singleton.class) { 
                    instance = new Singleton();
                }
            }
    
            return instance;
        }
    }

### 1.2.6 懒汉式（双重检查） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public class Singleton { 
    
        /** * 私有构造方法 */
        private Singleton() { };
    
        /** * 创建内部对象 */
        private static Singleton instance;
    
        /** * 获取实例 * @return Singleton */
        public static Singleton getInstance() { 
            if (null == instance) { 
                // 多个线程进入 if 中依然会出现问题
                synchronized (Singleton.class) { 
                    if (null == instance) { 
                        instance = new Singleton();
                    }
                }
            }
    
            return instance;
        }
    }

双重检查是同步代码块的升级版，在多线程开发中常使用到的，如代码中所示，我们进行了两次 if 检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断 if ，直接 return 实例化对象，也避免的反复进行方法同步。线程安全；延迟加载；效率较高。在实际开发中，推荐使用。

### 1.2.7 懒汉式（静态内部类） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public class Singleton { 
    
        /** * 私有构造方法 */
        private Singleton() { };
    
        /** * 创建静态内部类 */
        private static class SingletonInstance { 
            public static final Singleton INSTSNCE = new Singleton();
        }
    
        /** * 获取实例 * @return Singleton */
        public static synchronized Singleton getInstance() { 
            return SingletonInstance.INSTSNCE;
        }
    }

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getlnstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。类的静态属性只会在第一次加载类的时候初始化，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。避免了线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用。

### 1.2.8 懒汉式（枚举） ###

/** * @author Demo_Null * @version 1.0 * @date 2020/12/23 */
    public enum Singleton { 
        /** * 枚举项，是本类的实例 */
        INSTSNCE;
    
        /** * 其他方法 */
        public void show() { 
            System.out.println("Hello World!");
        }
    }

借助 JDK 1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。

[20201222144006346.png_pic_center]: /images/20221120/9fa8aaee28f94e0db9a84f87b8c07cbe.png