• 《设计模式》之单例模式

    在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

    一、单例模式的定义与特点

    单例（）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

    在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

    单例模式有 3 个特点：

    1. 单例类只有一个实例对象；
    2. 该单例对象必须由单例类自行创建；
    3. 单例类对外提供一个访问该单例的全局访问点；

    二、单例模式的结构与实现

    单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

    下面来分析其基本结构和实现方法。

    2.1、单例模式的结构

    单例模式的主要角色如下。

    • 单例类：包含一个实例且能自行创建这个实例的类。
    • 访问类：使用单例的类。

    其结构如图 1 所示。

    2.2、单例模式的实现

    Singleton 模式通常有两种实现形式。

    2.3.1、懒汉式单例

    该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下：

    1. public class LazySingleton
    2. {
    3.     private static volatile LazySingleton instance=null;    //保证 instance 在所有线程中同步
    4.     private LazySingleton(){}    //private 避免类在外部被实例化
    5.     public static synchronized LazySingleton getInstance()
    6.     {
    7.         //getInstance 方法前加同步
    8.         if(instance==null)
    9.         {
    10.             instance=new LazySingleton();
    11.         }
    12.         return instance;
    13.     }
    14. }

    注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

    2.3.2、饿汉式单例

    该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

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

    饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

    三、单例模式的八种写法

    3.1、饿汉式单例

    写法一: 

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * 饿汉式
    5.  * 类加载到内存后，就实例化一个单例，JVM保证线程安全
    6.  * 简单实用，推荐使用！
    7.  * 唯一缺点：不管用到与否，类装载时就完成实例化
    8.  * （话说你不用的，你装载它干啥）
    9.  */
    10. public class Mgr01 {
    11.  
    12.     private static final Mgr01 INSTANCE = new Mgr01();
    13.  
    14.     private Mgr01() {};
    15.  
    16.     public static Mgr01 getInstance() {
    17.         return INSTANCE;
    18.     }
    19.  
    20.     public void m() {
    21.         System.out.println("m");
    22.     }
    23.  
    24.     public static void main(String[] args) {
    25.         Mgr01 m1 = Mgr01.getInstance();
    26.         Mgr01 m2 = Mgr01.getInstance();
    27.         System.out.println(m1 == m2);
    28.     }
    29. }

    写法二:

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * 跟01是一个意思
    5.  */
    6. public class Mgr02 {
    7.     private static final Mgr02 INSTANCE;
    8.     static {
    9.         INSTANCE = new Mgr02();
    10.     }
    11.  
    12.     private Mgr02() {};
    13.  
    14.     public static Mgr02 getInstance() {
    15.         return INSTANCE;
    16.     }
    17.  
    18.     public void m() {
    19.         System.out.println("m");
    20.     }
    21.  
    22.     public static void main(String[] args) {
    23.         Mgr02 m1 = Mgr02.getInstance();
    24.         Mgr02 m2 = Mgr02.getInstance();
    25.         System.out.println(m1 == m2);
    26.     }
    27. }

    3.2、懒汉式单例

    写法一;

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * lazy loading
    5.  * 也称懒汉式
    6.  * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
    7.  */
    8. public class Mgr03 {
    9.     private static Mgr03 INSTANCE;
    10.  
    11.     private Mgr03() {
    12.     }
    13.  
    14.     public static Mgr03 getInstance() {
    15.         if (INSTANCE == null) {
    16.             try {
    17.                 Thread.sleep(1);
    18.             } catch (InterruptedException e) {
    19.                 e.printStackTrace();
    20.             }
    21.             INSTANCE = new Mgr03();
    22.         }
    23.         return INSTANCE;
    24.     }
    25.  
    26.     public void m() {
    27.         System.out.println("m");
    28.     }
    29.  
    30.     public static void main(String[] args) {
    31.         for(int i=0; i<100; i++) {
    32.             new Thread(()->
    33.                 System.out.println(Mgr03.getInstance().hashCode())
    34.             ).start();
    35.         }
    36.     }
    37. }

    写法二;

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * lazy loading
    5.  * 也称懒汉式
    6.  * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
    7.  * 可以通过synchronized解决，但也带来效率下降
    8.  */
    9. public class Mgr04 {
    10.     private static Mgr04 INSTANCE;
    11.  
    12.     private Mgr04() {
    13.     }
    14.  
    15.     public static synchronized Mgr04 getInstance() {
    16.         if (INSTANCE == null) {
    17.             try {
    18.                 Thread.sleep(1);
    19.             } catch (InterruptedException e) {
    20.                 e.printStackTrace();
    21.             }
    22.             INSTANCE = new Mgr04();
    23.         }
    24.         return INSTANCE;
    25.     }
    26.  
    27.     public void m() {
    28.         System.out.println("m");
    29.     }
    30.  
    31.     public static void main(String[] args) {
    32.         for(int i=0; i<100; i++) {
    33.             new Thread(()->{
    34.                 System.out.println(Mgr04.getInstance().hashCode());
    35.             }).start();
    36.         }
    37.     }
    38. }

    写法三:

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * lazy loading
    5.  * 也称懒汉式
    6.  * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
    7.  * 可以通过synchronized解决，但也带来效率下降
    8.  */
    9. public class Mgr05 {
    10.     private static Mgr05 INSTANCE;
    11.  
    12.     private Mgr05() {
    13.     }
    14.  
    15.     public static Mgr05 getInstance() {
    16.         if (INSTANCE == null) {
    17.             //妄图通过减小同步代码块的方式提高效率，然后不可行
    18.             synchronized (Mgr05.class) {
    19.                 try {
    20.                     Thread.sleep(1);
    21.                 } catch (InterruptedException e) {
    22.                     e.printStackTrace();
    23.                 }
    24.                 INSTANCE = new Mgr05();
    25.             }
    26.         }
    27.         return INSTANCE;
    28.     }
    29.  
    30.     public void m() {
    31.         System.out.println("m");
    32.     }
    33.  
    34.     public static void main(String[] args) {
    35.         for(int i=0; i<100; i++) {
    36.             new Thread(()->{
    37.                 System.out.println(Mgr05.getInstance().hashCode());
    38.             }).start();
    39.         }
    40.     }
    41. }

    写法四:

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * lazy loading
    5.  * 也称懒汉式
    6.  * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
    7.  * 可以通过synchronized解决，但也带来效率下降
    8.  */
    9. public class Mgr06 {
    10.     private static volatile Mgr06 INSTANCE; //JIT
    11.  
    12.     private Mgr06() {
    13.     }
    14.  
    15.     public static Mgr06 getInstance() {
    16.         if (INSTANCE == null) {
    17.             //双重检查
    18.             synchronized (Mgr06.class) {
    19.                 if(INSTANCE == null) {
    20.                     try {
    21.                         Thread.sleep(1);
    22.                     } catch (InterruptedException e) {
    23.                         e.printStackTrace();
    24.                     }
    25.                     INSTANCE = new Mgr06();
    26.                 }
    27.             }
    28.         }
    29.         return INSTANCE;
    30.     }
    31.  
    32.     public void m() {
    33.         System.out.println("m");
    34.     }
    35.  
    36.     public static void main(String[] args) {
    37.         for(int i=0; i<100; i++) {
    38.             new Thread(()->{
    39.                 System.out.println(Mgr06.getInstance().hashCode());
    40.             }).start();
    41.         }
    42.     }
    43. }

    写法五:

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * 静态内部类方式
    5.  * JVM保证单例
    6.  * 加载外部类时不会加载内部类，这样可以实现懒加载
    7.  */
    8. public class Mgr07 {
    9.  
    10.     private Mgr07() {
    11.     }
    12.  
    13.     private static class Mgr07Holder {
    14.         private final static Mgr07 INSTANCE = new Mgr07();
    15.     }
    16.  
    17.     public static Mgr07 getInstance() {
    18.         return Mgr07Holder.INSTANCE;
    19.     }
    20.  
    21.     public void m() {
    22.         System.out.println("m");
    23.     }
    24.  
    25.     public static void main(String[] args) {
    26.         for(int i=0; i<1000; i++) {
    27.             new Thread(()->{
    28.                 System.out.println(Mgr07.getInstance().hashCode());
    29.             }).start();
    30.         }
    31.     }
    32.  
    33.  
    34. }

    写法六:

    1. package com.company.singleton;
    2.  
    3. /**
    4.  * 不仅可以解决线程同步，还可以防止反序列化。
    5.  */
    6. public enum Mgr08 {
    7.  
    8.     INSTANCE;
    9.  
    10.     public void m() {}
    11.  
    12.     public static void main(String[] args) {
    13.         for(int i=0; i<100; i++) {
    14.             new Thread(()->{
    15.                 System.out.println(Mgr08.INSTANCE.hashCode());
    16.             }).start();
    17.         }
    18.     }
    19.  
    20. }

    四、单例模式的应用实例

    【例1】用懒汉式单例模式模拟产生美国当今总统对象。

    分析：在每一届任期内，美国的总统只有一人，所以本实例适合用单例模式实现，图 2 所示是用懒汉式单例实现的结构图。

    图2 美国总统生成器的结构图 

    程序代码如下：

    1. public class SingletonLazy
    2. {
    3.     public static void main(String[] args)
    4.     {
    5.         President zt1=President.getInstance();
    6.         zt1.getName();    //输出总统的名字
    7.         President zt2=President.getInstance();
    8.         zt2.getName();    //输出总统的名字
    9.         if(zt1==zt2)
    10.         {
    11.            System.out.println("他们是同一人！");
    12.         }
    13.         else
    14.         {
    15.            System.out.println("他们不是同一人！");
    16.         }
    17.     }
    18. }
    19. class President
    20. {
    21.     private static volatile President instance=null;    //保证instance在所有线程中同步
    22.     //private避免类在外部被实例化
    23.     private President()
    24.     {
    25.         System.out.println("产生一个总统！");
    26.     }
    27.     public static synchronized President getInstance()
    28.     {
    29.         //在getInstance方法上加同步
    30.         if(instance==null)
    31.         {
    32.                instance=new President();
    33.         }
    34.         else
    35.         {
    36.            System.out.println("已经有一个总统，不能产生新总统！");
    37.         }
    38.         return instance;
    39.     }
    40.     public void getName()
    41.     {
    42.         System.out.println("我是美国总统：特朗普。");
    43.     }  
    44. }

    程序运行结果如下：

    产生一个总统！
我是美国总统：特朗普。
已经有一个总统，不能产生新总统！
我是美国总统：特朗普。
他们是同一人！

    【例2】用饿汉式单例模式模拟产生猪八戒对象。

    分析：同上例类似，猪八戒也只有一个，所以本实例同样适合用单例模式实现。本实例由于要显示猪八戒的图像（点此下载该程序所要显示的猪八戒图片），所以用到了框架窗体 JFrame 组件，这里的猪八戒类是单例类，可以将其定义成面板 JPanel 的子类，里面包含了标签，用于保存猪八戒的图像，客户窗体可以获得猪八戒对象，并显示它。图 3 所示是用饿汉式单例实现的结构图。

    图3 猪八戒生成器的结构图

    程序代码如下：

    1. import java.awt.*;
    2. import javax.swing.*;
    3. public class SingletonEager
    4. {
    5.     public static void main(String[] args)
    6.     {
    7.         JFrame jf=new JFrame("饿汉单例模式测试");
    8.         jf.setLayout(new GridLayout(1,2));
    9.         Container contentPane=jf.getContentPane();
    10.         Bajie obj1=Bajie.getInstance();
    11.         contentPane.add(obj1);    
    12.         Bajie obj2=Bajie.getInstance(); 
    13.         contentPane.add(obj2);
    14.         if(obj1==obj2)
    15.         {
    16.             System.out.println("他们是同一人！");
    17.         }
    18.         else
    19.         {
    20.             System.out.println("他们不是同一人！");
    21.         }   
    22.         jf.pack();       
    23.         jf.setVisible(true);
    24.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    25.     }
    26. }
    27. class Bajie extends JPanel
    28. {
    29.     private static Bajie instance=new Bajie();
    30.     private Bajie()
    31.     { 
    32.         JLabel l1=new JLabel(new ImageIcon("src/Bajie.jpg"));
    33.         this.add(l1);   
    34.     }
    35.     public static Bajie getInstance()
    36.     {
    37.         return instance;
    38.     }
    39. }

    程序运行结果如图 4 所示。

    图4 猪八戒生成器的运行结果

    五、单例模式的应用场景 

    前面分析了单例模式的结构与特点，以下是它通常适用的场景的特点。

    • 在应用场景中，某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
    • 当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
    • 当某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

    六、单例模式的扩展

    单例模式可扩展为有限的多例（Multitcm）模式，这种模式可生成有限个实例并保存在 ArmyList 中，客户需要时可随机获取，其结构图如图 5 所示。

    图5 有限的多例模式的结构图 

    参考文章: 单例模式（单例设计模式）详解_smile_and_ovo的博客-CSDN博客_单例模式

  • 相关阅读:
    【数字识别】基于DBN实现minist数据集手写数字识别附matlab代码
    apt-mirror 制作麒麟桌面版内网源
    整点猛料！啃完阿里最新版Java面试八股文，大厂面试轻松搞定，拿下offer不是事儿！（金九银十同样适用）
    Collection集合 迭代器 增强for List集合 LinkedList集合详解
    【收藏系列】多线程八股文总结
    C++ 类型转换
    数据统计与可视化课程总结
    基于JavaSwing开发小区物业信息房屋出租管理系统 课程设计 大作业
    寻找旋转排序数组中的最小值 II[经典抽象二分 + 如何破局左中右三者相等]
    总结Redis的原理
  • 原文地址：https://blog.csdn.net/m0_50370837/article/details/126179908