Java设计模式——单例模式

最新推荐文章于 2024-09-04 17:41:34 发布
最新推荐文章于 2024-09-04 17:41:34 发布
阅读量103 收藏
点赞数 1
分类专栏： Java设计模式 文章标签： 单例模式 懒汉式 饿汉式 双重检查
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44039966/article/details/103105759
版权

简介
所谓单例模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得对象实例的方法（静态方法）

单例模式注意事项和使用说明

  • 单例模式保证了系统内存中只存在一个对象，节省了系统资源，对一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能

  • 实例化一个单例类时，要调用获取对象的方法而不是new

  • 单例模式使用场景：需要频繁创建和销毁的对象、创建对象时耗时过多或者耗费资源过多，但又经常用到的对象、工具类对象、频繁访问数据库或者文件的对象

单例模式的几种方法

  1. 饿汉式

  2. 懒汉式

  3. 双重检查

  4. 静态内部类

  5. 枚举

饿汉式

饿汉式细分又可以分为两种，一种是静态常量，一种是静态代码块

饿汉式（静态常量）

实现步骤

  1. 构造器私有化（防止new）

  2. 类的内部构造对象

  3. 向外暴露一个静态的公共方法获取对象实例

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

// 饿汉式（静态变量）
class Singleton {
    // 1、构造器私有化，外部不能new
    private Singleton() {
    }

    // 2、本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    // 3、提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

// 运行结果
true
====================
1735600054
1735600054

// 说明了这两个对象为同一个实例

优缺点：

  • 优点：写法简单，在类加载时完成实例化，避免了线程同步问题

  • 缺点：在类装载时完成实例化，没有达到懒加载的效果（Lazy Loading），如果程序从头到尾都没有使用这个实例，则会造成内存的浪费

结论：这种单例模式可用，但可能会造成内存浪费

饿汉式（静态代码块）

这种方式和静态常量方法非常相似，只不过是把单例初始化放到了静态代码块中，其他都不需要改变

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
        System.out.println("====================");
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

// 饿汉式（静态代码块）
class Singleton {
    // 1、构造器私有化，外部不能new
    private Singleton() {
    }

    // 2、本类内部创建对象实例
    private static Singleton instance;

    static {    // 在静态代码块中创建单例对象
        instance = new Singleton();
    }

    // 3、提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

// 运行结果
true
====================
1735600054
1735600054

// 说明了这两个对象为同一个实例

优缺点与结论
与饿汉式（静态常量）相同

懒汉式

懒汉式实现了懒加载，减少了内存空间的浪费

懒汉式（线程不安全）
public class SingleTonTest {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
        System.out.println("====================");
        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) {
            instance = new Singleton();
        }
        return instance;
    }
}

// 运行结果
true
====================
1735600054
1735600054

// 说明了这两个对象为同一个实例

优缺点

  • 优点：起到了懒加载的效果，但是只能在单线程下使用
  • 缺点：如果在多线程下，一个线程进入了if (instance == null)判断语句，还未来得及往下执行，另一个线程也通过了这个判断语句，这时就会产生多个实例，就不是单例模式了，所以在多线程下可能会有多个实例产生

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

懒汉式（线程安全，同步方法）

实现这种模式非常简单，只需要在线程不安全的获取实例方法代码中加上synchronized即可
在这里插入图片描述
这样线程就会排队执行getInstance方法，从而实现只有一个实例

优缺点：

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

  • 缺点：效率太低，想要获取类的实例时，每次执行getInstance方法都需要进行同步

  • 使用设计模式的目的则是提高程序效率，实际开发中，会经常调用getInstance方法，使得效率低下，这与我们的目的相悖

结论：实际开发中，不推荐使用

懒汉式（同步代码块）

有人想用这种方法来改进 懒汉式（线程安全，同步方法）实现提高效率，但这种方法其实是一种错误方法，不仅做不到提高效率，而且也无法实现线程安全

// 该方法的核心部分
public static Singleton getInstance() {
        if (instance == null) {
        	synchronized (Singleton.class){
        		instance = new Singleton();
			}  
        }
        return instance;
    }

把 synchronized 加到代码块上并不会提高效率，而且外层缺少了 synchronized 会造成有多个线程进入了if语句中，而进入了if语句就会创建一个实例，只不过现在是排队创建罢了

结论：白给写法，千万不要写

双重检查（推荐）

该模式不仅解决了线程安全问题，还是实现了懒加载，提高了效率

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
        System.out.println("====================");
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton {

    // volatile：将修改值立即更新到主存，防止重排序，相较synchronized来说是一个轻量级的，只能修饰变量
    private static volatile Singleton instance;
	
	// 构造器私有化
    private Singleton() {
    }

    // 提供一个公有的静态方法，加入双重检查代码，保证了只会有一个线程执行，解决线程安全问题和懒加载问题
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// 运行结果
true
====================
1735600054
1735600054

// 说明了这两个对象为同一个实例

说明：

  • 双重检查（Double-Check）是多线程开发中经常使用的，使用两次if (instance == null)检查保证线程安全

  • 实例化代码只执行了一次，后面再访问时直接return实例化对象，避免了反复的方法同步（方法同步效率很低）

  • 实现了懒加载，效率较高

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

静态内部类

当类被装载时，静态内部类不会被装载，当我们使用静态变量时，静态内部类才会被装载且只装载一次，而且类的装载过程中线程是安全的

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
        System.out.println("====================");
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton {

    // 构造器私有化
    private Singleton() {
    }

    // 写一个静态内部类，该类中有一个静态属性
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    // 提供一个公有的静态方法，直接返回静态内部类的成员变量
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

// 运行结果
true
====================
1735600054
1735600054

// 说明了这两个对象为同一个实例

说明：

  • 这种方式采用了类加载的机制保证初始化实例时只有一个线程

  • SingletonInstance类不会立即被装载，只有调用getInstance方法后才会装载SingletonInstance类，从而完成Singleton的实例化

  • 类的静态属性只会在第一加载类的时候初始化

  • 避免了线程不安全，利用静态内部类的特点实现懒加载，效率高

结论：推荐使用

枚举

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1 == instance2);
        System.out.println("====================");
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

enum Singleton {
    INSTANCE;   // 属性
    public void sayOK() {
        System.out.println("OK");
    }
}

说明：

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

结论：推荐使用

题外话：其实单例模式在我刚开始学Java的时候就接触到了，当时学线程的时候什么懒汉饿汉，双重检查，死锁什么的差点把我送走，但现在重新再看这个的话就感觉非常简单了，看来我也是有进步得嘛

驼君
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 设计模式——单例模式
斌林诚上的博客
11-08 879
  一、简介 二、作用 三、实现方式 说明 （1）第一种方式 （2）第二种方式 （3）第三种方式 （4）第四种方式 （5）第五种方式 （6）第六种方式 四、测试 五、源码地址 六、参考文档 七、内容推荐 一、简介 属于创建型模式，提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。 这个类提供了一种访问...
Java 设计模式——单例模式
代码星辰的博客
07-08 5193
本文介绍了单例模式的相关知识。
JAVA设计模式——单例模式
2301_77760093的博客
03-04 942
单例模式是一种创建型设计模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。单例模式通常用于需要在整个应用程序中共享某个资源或控制某个独占性资源的情况。在单例模式中，通常会将类的构造函数设为私有（private），以防止外部直接实例化该类。同时，类内部会维护一个静态成员变量来保存唯一的实例，并提供一个静态方法来获取或创建这个实例。单例模式有多种实现方式，包括懒汉式、饿汉式、双重检查锁等，需要注意的是，在多线程环境下，需要考虑线程安全性，确保单例模式能够正确地工作。
java设计模式——单例模式
hbw0226的博客
04-30 63
饿汉模式比较简单没有像懒汉模式那样实现方法多种多样。
Java设计模式 —— 单例模式
Designer 小郑的技术博客
05-31 3733
本文主要讲解Java设计模式中，最最基础的单例模式。
Java设计模式——单例模式的简单理解，懒汉式/饿汉式&单例模式使用场景
不会敲代码的笨兔子
11-10 1483
首先，单例（Singleton）设计模式是23中设计模式的一种，应用场景也比较广泛，这里只做一个简单了解 目标：熟悉饿汉式的实现过程，这个地方懒汉式还是有一些线程安全问题，我们学到多线程的时候再做优化 提取一下关键路径： 某个类只能存在一个对象实例-->构造器私有化，这个实例只能在类内部定义-->调用静态方法返回这个对象，这个方法必须是静态的才能被外面调用，不然外面就要声明这个类，又矛盾了-->静态的方法里面只能访问静态成员变量，所以这个类的对象也是静态的。 我们通过..
设计模式-单例模式
xujinwei_gingko的专栏
09-01 309
饿汉式：类加载时直接创建实例，类加载时已经生成示例，所以。懒汉式：用到实例的时候再创建，多线程场景下，单例模式分为饿汉式、懒汉式。
【设计模式】单例模式
秋玄的博客
09-04 882
设计模式——单例模式
[线程]单例模式 及 指令重排序
m0_73992740的博客
08-31 888
比如, 你写的服务器, 要从硬盘上加载100G的数据到内存中, 肯定要写一个类, 封装上述加载操作, 并且写一些获取 / 处理数据的业务逻辑, 这样的类, 就应该是单例的, 因为一个实例, 就要管理100G的内存数据, 搞多个实例, 就是N * 100G的内存数据, 机器肯定吃不消, 也没必要搞这么多重复的。其实, 指令重排序问题很能验证, 本身就是一个 小概率事件, 即使不加volatile, 运行很多次, 也是正确的, 但是指不定啥时候会出现问题, 我们能做的就是把volatile该加的加上即可。
设计模式 —— 单例模式
weixin_44814196的博客
09-04 255
单例模式（Singleton Pattern）是一个比较简单的模式，其定义如下：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
前端常用的几种设计模式--观察者模式、单例模式等
faith_girl的博客
09-04 354
这种模式被广泛应用在 JavaScript 中，用来创建模块，这些模块可以有私有和公有的方法和变量。也被称为发布/订阅模式，这种模式允许对象订阅另一对象的特定活动并在适当的时候被通知。这种模式允许在运行时动态地为对象添加新的行为。这是 JavaScript 的核心模式，由于 JavaScript 是基于原型的，所以它在 JavaScript 的对象创建和继承中起着重要的作用。以上这些模式并不是前端开发者必须要记住的，但对于写出高质量代码以及理解现代 JavaScript 框架和库的工作原理是非常有帮助的。
微信小程序书店（微信端）+源代码+演示视频.zip
09-04
互联网发展至今，无论是其理论还是技术都已经成熟，而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播，搭配信息管理工具可以很好地为人们提供服务。针对高校教师成果信息管理混乱，出错率高，信息安全性差，劳动强度大，费时费力等问题，采用微信小程序书店可以有效管理，使信息管理能够更加科学和规范。 微信小程序书店使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理微信小程序书店信息，查看微信小程序书店信息，管理微信小程序书店。 总之，微信小程序书店集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。 关键词：微信小程序书店；Java语言；Mysql
用户调研问题清单SOP（以燕窝行业为例）.xlsx
09-04
用户调研问题清单SOP（以燕窝行业为例）
jquery swiper插件使用案例demo.rar
09-04
Swiper是一个纯JavaScript打造的滑动特效插件，面向手机、平板电脑等移动终端，同时也支持桌面浏览器。Swiper开源、免费、稳定、使用简单且功能强大，是架构移动终端网站的重要选择。 【加载插件】 首先加载插件，需要用到的文件有swiper-bundle.min.js和swiper-bundle.min.css文件，不同Swiper版本用到的文件名略有不同。可下载Swiper文件或使用CDN。 使用Swiper插件的步骤主要包括以下几个部分： ‌1、下载Swiper插件‌：首先，需要从Swiper的官网(https://swiper.com.cn/)下载Swiper插件。官网提供了多种版本的下载链接，包括压缩版和未压缩版，以及包含动画效果的版本等，可以根据项目需求选择合适的版本下载。 ‌2、引入Swiper文件‌：下载完成后，将Swiper的CSS和JS文件引入到项目中。通常，这两个文件分别是swiper-bundle.min.css和swiper-bundle.min.js（文件名可能因版本而异）。例如，在HTML中引入这些文件的代码
A New Semantic Similarity Scheme for more Accurate
09-04
A New Semantic Similarity Scheme for more Accurate
2019-2021office2019-2021office
最新发布
09-04
2019-2021office2019-2021office
Java面试：设计模式详解——单例、工厂、抽象工厂与代理模式
"本文主要介绍了Java面试中常见的几种设计模式，包括单例模式、工厂模式、抽象工厂模式、代理模式以及MVC模式，并通过实际例子帮助理解这些模式的原理和应用。" ### 单例模式 单例模式是一种限制类只能拥有一个实例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值