《设计模式》之单例模式

已于 2022-08-13 10:55:19 修改
阅读量197 收藏
点赞数 1
分类专栏： 23种设计模式 文章标签： 单例模式 设计模式 java
于 2022-08-05 19:29:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50370837/article/details/126179908
版权

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

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

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

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

单例模式有 3 个特点：

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

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

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

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

2.1、单例模式的结构

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

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

其结构如图 1 所示。

2.2、单例模式的实现

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

2.3.1、懒汉式单例

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

public class LazySingleton
{
    private static volatile LazySingleton instance=null;    //保证 instance 在所有线程中同步
    private LazySingleton(){}    //private 避免类在外部被实例化
    public static synchronized LazySingleton getInstance()
    {
        //getInstance 方法前加同步
        if(instance==null)
        {
            instance=new LazySingleton();
        }
        return instance;
    }
}

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

2.3.2、饿汉式单例

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

public class HungrySingleton
{
    private static final HungrySingleton instance=new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance()
    {
        return instance;
    }
}

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

三、单例模式的八种写法

3.1、饿汉式单例

写法一: 

package com.company.singleton;

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 * （话说你不用的，你装载它干啥）
 */
public class Mgr01 {

    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

写法二:

package com.company.singleton;

/**
 * 跟01是一个意思
 */
public class Mgr02 {
    private static final Mgr02 INSTANCE;
    static {
        INSTANCE = new Mgr02();
    }

    private Mgr02() {};

    public static Mgr02 getInstance() {
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        Mgr02 m1 = Mgr02.getInstance();
        Mgr02 m2 = Mgr02.getInstance();
        System.out.println(m1 == m2);
    }
}

3.2、懒汉式单例

写法一;

package com.company.singleton;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 */
public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->
                System.out.println(Mgr03.getInstance().hashCode())
            ).start();
        }
    }
}

写法二;

package com.company.singleton;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {
    }

    public static synchronized Mgr04 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr04.getInstance().hashCode());
            }).start();
        }
    }
}

写法三:

package com.company.singleton;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {
    }

    public static Mgr05 getInstance() {
        if (INSTANCE == null) {
            //妄图通过减小同步代码块的方式提高效率，然后不可行
            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

写法四:

package com.company.singleton;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

写法五:

package com.company.singleton;

/**
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 */
public class Mgr07 {

    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

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

    public static void main(String[] args) {
        for(int i=0; i<1000; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }


}

写法六:

package com.company.singleton;

/**
 * 不仅可以解决线程同步，还可以防止反序列化。
 */
public enum Mgr08 {

    INSTANCE;

    public void m() {}

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }

}

四、单例模式的应用实例

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

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

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

程序代码如下：

public class SingletonLazy
{
    public static void main(String[] args)
    {
        President zt1=President.getInstance();
        zt1.getName();    //输出总统的名字
        President zt2=President.getInstance();
        zt2.getName();    //输出总统的名字
        if(zt1==zt2)
        {
           System.out.println("他们是同一人！");
        }
        else
        {
           System.out.println("他们不是同一人！");
        }
    }
}
class President
{
    private static volatile President instance=null;    //保证instance在所有线程中同步
    //private避免类在外部被实例化
    private President()
    {
        System.out.println("产生一个总统！");
    }
    public static synchronized President getInstance()
    {
        //在getInstance方法上加同步
        if(instance==null)
        {
               instance=new President();
        }
        else
        {
           System.out.println("已经有一个总统，不能产生新总统！");
        }
        return instance;
    }
    public void getName()
    {
        System.out.println("我是美国总统：特朗普。");
    }  
}

程序运行结果如下：

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

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

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

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

程序代码如下：

import java.awt.*;
import javax.swing.*;
public class SingletonEager
{
    public static void main(String[] args)
    {
        JFrame jf=new JFrame("饿汉单例模式测试");
        jf.setLayout(new GridLayout(1,2));
        Container contentPane=jf.getContentPane();
        Bajie obj1=Bajie.getInstance();
        contentPane.add(obj1);    
        Bajie obj2=Bajie.getInstance(); 
        contentPane.add(obj2);
        if(obj1==obj2)
        {
            System.out.println("他们是同一人！");
        }
        else
        {
            System.out.println("他们不是同一人！");
        }   
        jf.pack();       
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}
class Bajie extends JPanel
{
    private static Bajie instance=new Bajie();
    private Bajie()
    { 
        JLabel l1=new JLabel(new ImageIcon("src/Bajie.jpg"));
        this.add(l1);   
    }
    public static Bajie getInstance()
    {
        return instance;
    }
}

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

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

五、单例模式的应用场景 

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

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

六、单例模式的扩展

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

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

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

向上的狼
关注
专栏目录
单例模式（懒汉式，饿汉式）
10-31
单例模式（有常用的懒汉式单例类，饿汉式单例类）
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
设计模式--单例模式（Singleton）
吴声子夜歌的博客
08-24 1126
单例模式（Singleton） 在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义： 指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等...
设计模式——单例模式（Singleton）
chenchen_fcj程序猿的博客
04-09 168
单例模式定义： 一种对象创建型模式， 使用单例模式， 可以保证为一个类只生成唯一的实例对象。 也就是说， 在整个程序空间中， 该类只存在一个实例对象。 从结构图可以看出，构造函数是私有的。 为什么需要单例模式： 1、在多个线程之间，比如初始化一次socket资源 2、在整个程序空间使用全局变量，共享资源 3、大规模系统中，为了性能的考虑，需要节省对象的创建时间 ...
单例（Singleton）设计模式
PanADE的博客
07-21 385
定义 确保某个类只有一个实例，并且自行实例化，向整个程序提供实例对象 使用场景 创建某个对象很耗费资源或者某一种类型的对象只应该有一个的时候，比如线程池（threadpool）、缓存（cache）、对话框、日志对象、处理偏好设置、打印机、显卡等对象，只应该有一个，如果制造出了多个对象，那么就有可能造成程序的异常行为，资源使用过量或者结果不一致等问题。 单例设计模式的实现 1、...
设计之模式之单例（Singleton）
学海无涯
02-29 102
[color=red][b]主要作用：[/b][/color]Singleton模式主要作用是保证在Java应用程序中，一个类只有一个实例存在。在很多操作中，比如建立目录、数据库连接都需要这样的单线程操作以达到对系统资源的访问进行控制之目的。单例模式只应在有真正的“单一实例”的需求时才可使用。 [color=red][b]优点：[/b][/color]Singleton模式就为我们提供了这样实现...
c#设计模式之单例模式的实现方式
12-26
单例模式对于我们来说一点也不模式，是一个常见的名称，单例模式在程序中的实际效果就是：确保一个程序中只有一个实例，并提供一个全局访问点，节省系统资源 单例模式无论是在实际开发中还是在软件应用中比较常见，...
C# 设计模式之单例模式归纳总结
08-30
C# 设计模式之单例模式是一种常用的设计模式，它限制了类的实例化，使得某个类只能有一个实例，并提供了一个全局访问点来访问该实例。本文将对单例模式的定义、优缺点、实现要点和适用性进行详细的讲解。 单例模式...
JAVA设计模式之单例模式
最新发布
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
Android编程设计模式之单例模式实例详解
01-04
单例模式是应用最广的模式之一，也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的...
JAVA设计模式-单例模式(Singleton)的五种实现方式
Mr_PH的博客
10-10 435
单例(Singleton)模式 也叫单态模式 我在另一篇文章中已经介绍过了过关于单例模式的简单描述和优缺点，感兴趣的朋友可以点击下面的连接，在这里我就不在赘述。 单例模式(Singleton)应用场景和优缺点 本篇文章主要介绍单例模式常见的5种实现方式，分别是：懒汉式、饿汉式、双重检测锁式、静态内部类式和枚举单例。下面我将为大家逐个介绍他们的特点和实现方式。 饿汉式（线
设计模式之单例模式（Singleton）
天码丶行满
08-27 174
1、定义 单例模式（Singleton Pattern）是最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 2、介绍 优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁...
设计模式 单例设计模式（Singleton Pattern）详细解读
小魔王博客
06-11 501
文章目录一、什么是单例设计模式？二、适用场景三、设计思想演进四、饿汉式结果五、懒汉式-懒加载（Lazy Load）初步改造线程安全问题和解决思路结果为何要加volatile？六、静态内部类实现单例设计模式（推荐）结果七、枚举实现单例设计模式结果八、问题：遇到反序列化、反射攻击怎么办？如何避免1、使用枚举2、解决反射问题3、解决反序列化最终测试 一、什么是单例设计模式？ 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象
单例模式 java作用特点_JAVA 设计模式之单例模式
weixin_33529455的博客
02-25 515
单例模式的定义就是确保某一个类仅有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式分为：懒汉式单例、饿汉式单例、登记式单例三种。单例模式特点如下：1)单例类只能有一个实例。2)单例类必须自己创建自己的唯一实例。3)单例类必须给所有其他对象提供这一实例。单例模式的优点是内存中只有一个对象，节省内存空间；避免频繁的创建销毁对象，可以提高性能；避免对资源...
单例模式（singleton）
pmc0_0的博客
07-02 162
文章目录单例模式解释形式饿汉式（静态常量）优点缺点饿汉式（静态代码块）优缺点和上面一样懒汉式（线程不安全）优点缺点懒汉式（线程安全，同步方法）优缺点分析懒汉式（线程安全，同步代码块）结论双重检查优点静态内部类优点枚举优点使用场景 单例模式 解释 单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 形式 饿汉式（静态常量） 饿汉式（静态代码块） 懒汉式（线程不安全） 懒汉式（线程安全，同步方法） 懒汉式（线程安全，同
设计模式详解（1）——单例模式
weixin_39174824的博客
07-05 807
设计模式详解（1）——单例模式 在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误...
单例模式—懒汉模式
weixin_44588315的博客
07-18 196
因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导 致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多种实现方式，各自的特性不相同，使 用的情形也不相同。今天要实现的是常用的三种，分别是饿汉式、懒汉式和多线程式。 单例模式的要点有三个： 单例类只能有一个实例 它必须自行创建这个实例 它必须自行向整个系统提供提供这个实...
java-------单例设计模式
解忧小店
06-06 189
java ----------单例设计模式 定义： ​ 指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 优点： 单例模式可以保证内存里只有一个实例，减少了内存的开销。 可以避免对资源的多重占用。 单例模式设置全局访问点，可以优化和共享资源的访问。 缺点： 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，
设计模式-01单例模式
数字人生
07-07 115
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值