单例模式详细总结（8种实现方式，看完就会）

已于 2023-04-09 21:45:38 修改
阅读量1.6k 收藏 11
点赞数 7
分类专栏： JAVA版设计模式 文章标签： 设计模式 java Powered by 金山文档
于 2023-01-10 17:10:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59957669/article/details/128632577
版权

单例模式

实现单例模式的8种方式：

饿汉式(静态变量)

优点：类装载时完成实例化，避免线程同步

缺点：没有达到Lazy Loading的效果，如果从始至终未使用过这个实例，会造成内存浪费

public class SingletonTest01 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(instance.hashCode()); // 356573597
        System.out.println(instance2.hashCode()); // 356573597
    }

}
// 单例模式
// 饿汉式(静态变量)
class Singleton {
    // 1. 构造器私有化
    private Singleton() {}
    // 2. 本类内部创建对象实例
    private final static Singleton instance = new Singleton(); // 静态变量
    // 3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

jdk源码中的 Runtime 就使用了这种方式实现单例模式

饿汉式(静态代码块)

优缺点同上

public class SingletonTest02 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(instance.hashCode()); // 356573597
        System.out.println(instance2.hashCode()); // 356573597
    }

}
// 单例模式
// 饿汉式(静态代码块)
class Singleton {
    // 1. 构造器私有化
    private Singleton() {}
    // 2. 本类内部创建对象实例
    private static Singleton instance;
    // 3. 静态代码块
    static {
        instance = new Singleton();
    }
    // 4. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}
懒汉式(线程不安全)

优点：Lazy loading(懒加载)

缺点：只能在单线程下使用。

如果在多线程下，一个线程进入了 if(instance == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，故，在多线程环境下，不可使用这种方式。

结论：实际开发中，不使用这种方式。

public class SingletonTest3 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(instance.hashCode()); // 356573597
        System.out.println(instance2.hashCode()); // 356573597
    }
}
// 懒汉式单例模式
class Singleton {
    private static Singleton instance;

    private Singleton() {}
    // 提供一个静态的公有方法，当使用到该方法时，才去创建instance
    // 即懒汉式
    public static Singleton getInstance() {
        if (instance == null) { // 线程不安全
            instance = new Singleton();
        }
        return instance;
    }
}
懒汉式(线程安全)

优点：解决了线程不安全问题

缺点：效率太低了，每个线程在想获得类的实例时，执行 getInstance()方法 都要

进行同步。而其实这个方法只执行一次实例化代码就够了，后面想获得直接 return 就行了。方法进行同步效率太低

结论：在实际开发中，不推荐。

public class SingletonTest4 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(instance.hashCode()); // 356573597
        System.out.println(instance2.hashCode()); // 356573597
    }
}
// 懒汉式单例模式(线程安全)
class Singleton {
    private static Singleton instance;

    private Singleton() {}
    // 提供一个静态的公有方法，并对该方法进行加synchronized进行线程同步，当使用到该方法时，才去创建instance
    public static synchronized Singleton getInstance() {// 线程安全
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
懒汉式(线程并不安全，同步代码块)

  1. 本意是想对第四种方式的改进，因而，从同步方法该为了同步产生实例化的代码块。

  1. 其实并没有起到线程同步的作用，假如一个线程进入了 if(instance == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个 判断语句块，这时便会产生多个实例。

结论：在实际开发中，不能使用这种方式。

public class SingletonTest5 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}
// 懒汉式单例模式(其实线程并不安全)
class Singleton {
    private static Singleton instance;

    private Singleton() {}
    // 提供一个静态的公有方法，当使用到该方法时，才去创建instance
    // 即懒汉式
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) { // 其实并不能保证线程安全
                instance = new Singleton();
            }
        }
        return instance;
    }
}
双重检查(DoubleCheck)

  1. 多线程开发中经常使用，进行两次 if(instance == null) 检查，保证线程安全。

  1. 实例化代码只会执行一次，之后再次访问时，直接return实例化对象，也避免了反复进行方法同步。

  1. 线程安全、lazy loading(延迟加载)、效率高。

结论：实际开发中，推荐这种单例设计模式。

public class SingletonTest6 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(instance.hashCode()); // 356573597
        System.out.println(instance2.hashCode()); // 356573597
    }
}
// 懒汉式单例模式(线程安全)
class Singleton {
    // 1. volattle 保证 可见性，当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值
    private static volatile Singleton instance;
	// 2. 构造器私有化
    private Singleton() {}
    // 3. 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题。
    // 还保证了效率，推荐使用。
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) { //
                if (instance == null) { // 双重检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
静态内部类

  1. 采用类装载的机制来保证初始化实例时只有一个线程。

  1. 静态内部类在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingleInstance类，从而实现Singleton的实例化。

  1. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

  1. 优点：避免线程不安全、利用静态内部类的特点实现延迟加载，效率高。推荐使用

public class SingletonTest7 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(instance.hashCode()); // 356573597
        System.out.println(instance2.hashCode()); // 356573597
    }
}

// 静态内部类实现
class Singleton {
    // 构造器私有化
    private Singleton() {}
    // 写一个静态内部类，含一个静态属性Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    // 提供一个静态的公有方法，直接返回SingleInstance.INSTANCE
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}
枚举

  1. 借助了 JDK1.5 中添加的枚举来实现单例模式，不仅避免了多线程同步问题，而且还防止反序列化重新创建新的对象。

  1. 推荐使用

public class SingletonTest8 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2); //true
        System.out.println(instance.hashCode()); // 356573597
        System.out.println(instance2.hashCode()); // 356573597

    }
}
// 枚举实现单例
enum Singleton {
    INSTANCE; // 属性
    public void sayOk() {
        System.out.println("ok~");
    }
}
-62
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
–设计模式–五种实现单例模式的方式
12-21
往下学习单例模式吧■ 章节目录■ 前言■ 什么是单例模式？① 应用场景实例② 模式优点③ 模式缺点④ 注意事项■ 单例模式的五种实现方式饿汉式代码实现懒加载代码实现双重检测锁代码实现静态内部类代码实现(也是懒加载的一种方式)枚举代码实现:diamond_suit: 总结 ■ 章节目录 ■ 前言 由于涉及到挺多关于线程这一块的知识，如果自己线程相关知识不是很清楚的话，可以去看看这篇文章噢
C++ 单例模式的几种实现方式研究
08-26
单例模式，可以说设计模式中最常应用的一种模式了，据说也是面试官最喜欢的题目。但是如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况
单例模式的5种实现方式，最后一种最推荐
最新发布
QiuMing
02-18 1079
单例模式有多种实现方式，选择哪种方式取决于你的具体需求。如果你希望在程序启动时就创建实例，可以选择饿汉式；如果你希望在需要时才创建实例，可以选择懒汉式、静态内部类或枚举。在多线程环境下，需要注意线程安全问题。希望本文能帮助你更好地理解和使用单例模式。
c#单例模式（Singleton）的6种实现
12-31
1.1.1 摘要  在我们日常的工作中经常需要在应用程序中保持一个唯一的实例，如：IO处理，数据库操作等，由于这些对象都要占用重要的系统资源，所以我们必须限制这些实例的创建或始终使用一个公用的实例，这就是我们今天要介绍的——单例模式（Singleton）。  使用频率高 单件模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 1.1.2 正文 图1单例模式（Singleton）结构图 单例模式（Singleton）是几个创建模式中最对立的一个，它的主要特点不是根据用户程序调用生成一个新的实例，而是控制某个类型的实例唯一性，通过上图我们知道它包含的角色只有一个，
Java单例模式实现的几种方式
09-01
主要介绍了Java单例模式实现的几种方式的相关资料,需要的朋友可以参考下
单例模式的代码实现
qq_41606722的博客
08-07 3542
​单例模式有八种方式： 饿汉式（静态常量，可以用） 饿汉式（静态代码块，可以用） 懒汉式（线程不安全，不可以使用） 懒汉式（线程安全，同步方法，不可以使用） 懒汉式（线程不安全，同步代码块，不可以使用） 双重检查（推荐使用） 静态内部类（推荐使用） 枚举（推荐使用） 一、饿汉式（静态常量） //饿汉式（静态变量）class Singleton { //私有化构造器，外部不能new private
单例模式的几种实现方式
05-05
单例模式的几种实现方式Demo
Java实现单例的几种方式
weixin_34315485的博客
03-30 1736
1. 什么是单例模式 单例模式指的是在应用整个生命周期内只能存在一个实例。单例模式是一种被广泛使用的设计模式。他有很多好处，能够避免实例对象的重复创建，减少创建实例的系统开销，节省内存。 2. 单例模式和静态类的区别 首先理解一下什么是静态类，静态类就是一个类里面都是静态方法和静态field，构造器被private修饰，因此不能被实例化。...
1. java设计模式：单例模式
Class雷
09-29 392
单例模式是代码最少的模式了。 一、简介 因程序需要，有时我们只需要某个类同时保留一个对象，不希望有更多对象，此时，我们则应考虑单例模式的设计 二、特点 单例模式只能有一个实例； 单例类必须创建自己的唯一实例； 单例模式必须向其他对象提供这一实例； 单例模式分为以下几种实现方法： 懒汉式，线程不安全 懒汉式，线程安全 饿汉式 双检锁/双重校验锁（DCL...
[读书笔记] 单例模式的几种实现方式
weixin_33675507的博客
11-24 87
Time:3 hours 从形式上来看，Singleton Pattern是所有模式中最简单的一种，但是细究起来并不像想象中那么简单。 Singleton的实现有多种方式（见下表及文后所附代码示例）。最基本的是第一种实现，这种实现最大的问题就是不支持多线程。《Head First Design Pattern》第五章列举了三种支持多线程的单例模式实现方式（表中第二、三、四...
java：单例模式的五种实现方式
weixin_42602900的博客
04-24 1万+
目录 1. 概述 2. 优缺点 3. 单例模式实现方式 3.1 饿汉式 3.2 懒汉式 3.3 double-checked locking（双重检查锁） 3.4 静态内部类 3.5 枚举 1. 概述 java单例模式是一种常见的设计模式。 单例模式有以下特点： 单例类只能有一个实例； 单例类必须自己创建自己的唯一实例； 单例类必须给所有其他对象提供这一实例； 2. 优缺点 优点：由于单例模式只生成了一个实例，所以能够节约系统资源，减少性能开销，提高系统运行效率。 缺点：因为系统中只有一个实例，导致了单
包你懂设计模式之：单例模式（三种实现）
maaici的博客
08-13 1091
单例模式属于创建型的设计模式，它的产生是为了解决“一个类只能有一个实例”，它的定义为：“保证一个类只能有一个实例，并提供一个访问它的全局访问点”，从字面上的理解是很简单的，且看如何操作实现。 一、常规实现 1、私有化构造函数，不允许外部实例化 创建对象的实例我们用New关键字，后面跟上类的构造方法，这样我们就完成了一次对象的创建，很显然我们按照这样的方法操作多次就会产生多个实例，所以我们为了防止类被多次实例化，首先要做的就是将构造函数私有化（public 改成 private）。 2、提供一个外..
设计模式（二）单例模式的七种写法
热门推荐
Android进阶三部曲 - 刘望舒
01-17 7万+
面试的时候，问到许多年轻的Android开发他所会的设计模式是什么，基本上都会提到单例模式，但是对单例模式也是一知半解，在Android开发中我们经常会运用单例模式，所以我们还是要更了解单例模式才对。 **定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。**
2020-12-23
wubaoyu123的博客
12-23 243
博客园Logo 首页 新闻 博问 专区 闪存 班级 代码改变世界 搜索 注册 登录 返回主页 码农充电站 专注编程技术分享 博客园 首页 新随笔 联系 订阅 管理 单例模式的五种实现方式及优缺点 公号：码农充电站pro 主页：https://codeshellme.github.io 当我们需要使得某个类只能有一个实例时，可以使用单例模式。 单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。 单例模式的实现需要三个必要的条件： 单例类的构造函数必须是
单例模式的五种实现方式（饿汉式、懒汉式、DCL懒汉式、静态内部类式、枚举单例）、优缺点比较
qq_44676946的博客
11-17 987
单例模式 原文链接：https://www.kuangstudy.com/bbs/1374623824745635841 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。
单例模式的实现方式
u013844719的博客
04-01 1283
1 最原始的实现单例模式的方法（存在线程不安全）：public class SingletonOne {    private static SingletonOne instance = null;    private SingletonOne() {}    public static SingletonOne getInstance() {        if (instance == n...
python单例模式继承_Python四种实现单例模式的方法
06-02
Python中实现单例模式的方式有很多种，其中包括以下四种方法： 1. 使用模块实现单例模式：Python的模块在程序中只会被导入一次，可以利用这个特性来实现单例模式。我们可以将需要实现单例模式的类定义在一个模块中，其他程序在需要使用该类时，直接导入该模块即可。 2. 使用装饰器实现单例模式：利用装饰器的特性，在创建类时动态地给类添加一个单例模式的实例属性。每次实例化该类时，都先判断该实例属性是否已经存在，如果存在，则直接返回该实例属性；如果不存在，则创建一个新的实例属性。 3. 使用元类实现单例模式：元类是用来创建类的类，我们可以通过定义一个元类，在创建类时动态地给类添加一个单例模式的实例属性。每次实例化该类时，都先判断该实例属性是否已经存在，如果存在，则直接返回该实例属性；如果不存在，则创建一个新的实例属性。 4. 使用基类实现单例模式：定义一个基类，在该基类中实现单例模式的逻辑。其他需要实现单例模式的类可以继承该基类，并重写__new__方法，使得每次实例化该类时都返回同一个实例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-62

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值