Java设计模式之单例设计模式

于 2023-04-25 19:35:48 发布
阅读量167 收藏 1
点赞数 3
分类专栏： 设计模式 知识分享 学习 文章标签： java 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51151870/article/details/130372310
版权

单例设计模式介绍

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

比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。

单例设计模式的八种方式

  • 饿汉式(静态常量)
  • 饿汉式（静态代码块）
  • 懒汉式(线程不安全)
  • 懒汉式(线程安全，同步方法)
  • 懒汉式(线程安全，同步代码块)
  • 双重检查
  • 静态内部类
  • 枚举

饿汉式（静态变量）

应用实例

步骤如下：

  • 构造器私有化 (防止 new )
  • 类的内部创建对象
  • 向外暴露一个静态的公共方法。getInstance
  • 代码实现
/**
 * @Author: abb
 * @DateTime: 2023-04-21 8:57
 * @Description: 饿汉式（静态变量）
 **/
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=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton {
    //1、构造器私有化，外部不能new
    private Singleton() {

    }
    //2、本类内部创建对象实例
    private final static Singleton instance = new Singleton();
    //3、提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点

  • 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
  • 缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
  • 这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
  • 结论：这种单例模式可用，可能造成内存浪费

饿汉式（静态代码块）

应用实例

这种方式和上面的方式其实类似，代码如下：

/**
 * @Author: abb
 * @DateTime: 2023-04-21 8:59
 * @Description: 饿汉式（静态代码块）
 **/
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=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton {
    //1、构造器私有化，外部不能new
    private Singleton() {

    }
    //2、本类内部创建对象实例
    private static Singleton instance;
    static {//在静态代码块中，创建单例对象
        instance=new Singleton();
    }
    //3、提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点

  • 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
  • 结论：这种单例模式可用，但是可能造成内存浪费

懒汉式（线程不安全）

代码演示

/**
 * @Author: abb
 * @DateTime: 2023-04-21 10:09
 * @Description: 懒汉式（线程不安全）
 **/
public class SingletonTest03 {
    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=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton {
    private static Singleton instance;

    //1、构造器私有化，外部不能new
    private Singleton() {

    }

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

优缺点

  • 起到了 Lazy Loading 的效果，但是只能在单线程下使用。
  • 如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
  • 结论：在实际开发中，不要使用这种方式.

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

代码演示

/**
 * @Author: abb
 * @DateTime: 2023-04-21 10:14
 * @Description: 懒汉式（线程安全、同步方法）
 **/
public class SingletonTest04 {
    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=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton {
    private static Singleton instance;

    //1、构造器私有化，外部不能new
    private Singleton() {

    }

    //2、提供一个公有的静态方法，只有使用到该方法时，才去创建instance，即懒汉式
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点

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

懒汉式（线程安全，同步代码块）

代码演示

/**
 * @Author: abb
 * @DateTime: 2023-04-21 10:18
 * @Description: 懒汉式（线程安全、同步代码块）
 **/
public class SingletonTest05 {
    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=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton {
    private static Singleton singleton;

    //1、构造器私有化，外部不能new
    private Singleton() {

    }

    //2、提供一个公有的静态方法，只有使用到该方法时，才去创建instance，即懒汉式
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

分析问题

  • 上述代码其实没有实现单例，假如有两个线程a,b同时进入了if判断，a在进行了对象的创建时，虽然b在外面等待，但是当a创建完毕之后，b线程会进入代码块执行对象的创建，这样就创建了两个对象，不符合单例设计模式。
  • 不使用

双重检查

代码演示

/**
 * @Author: abb
 * @DateTime: 2023-04-21 10:28
 * @Description: 双重检查
 **/
public class SingletonTest06 {
    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=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton {
    //volatile是Java提供的一种轻量级的同步机制。
    //当一个线程修改共享变量后他会立即被更新到主内存中
    private static volatile Singleton singleton;

    //1、构造器私有化，外部不能new
    private Singleton() {

    }

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

优缺点

  • Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
  • 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
  • 线程安全；延迟加载；效率较高
  • 结论：在实际开发中，推荐使用这种单例设计模式

静态内部类

代码演示

/**
 * @Author: abb
 * @DateTime: 2023-04-21 10:36
 * @Description: 静态内部类
 **/
public class SingletonTest07 {
    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=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton {
    private static Singleton singleton;

    //1、构造器私有化，外部不能new
    private Singleton() {

    }
    //写一个静态内部类，该类有一个静态属性INSTANCE
    private static class SingletonInstance{
        private static final Singleton INSTANCE=new Singleton();
    }
    //编写一个公有的静态方法，直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

优缺点

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

枚举

代码演示

/**
 * @Author: abb
 * @DateTime: 2023-04-21 11:21
 * @Description: 枚举
 **/
public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode()); 
        System.out.println(instance2.hashCode());
        instance.hello();
    }
}

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

优缺点

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

单例设计模式注意事项和细节

  • 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  • 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
  • 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

结束语

这次的设计模式之单例模式的学习到此就结束了，不知道大家是否已经了解并且掌握了呢，如有知识点和内容上面的错误，请及时联系我来改正

豪想敲代码
关注
专栏目录
单例模式详解
qq_45564691的博客
10-17 156
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Win...
Java设计模式-单例设计模式
freelome的博客
04-02 106
设计模式之一：单例设计模式 单例设计模式 需要解决的问题：保证在一个软件系统中，对某个类只能存在一个对象实例。
java设计模式之单例设计模式
qq_45946517的博客
08-09 128
两种方式的不同点：饿汉式是在类加载时就创建了对象实例，懒汉式只有在使用时才会创建对象实例。
JAVA设计模式之单例模式
最新发布
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
全面解析Java设计模式之单例模式
08-28
单例模式是设计模式中的一种基础模式，它确保一个类在任何情况下只有一个实例存在。这种模式的核心在于限制类的实例化，保证全局范围内只有一个对象，同时也提供了一个全局访问点，使得其他部分的代码能够方便地使用...
Java设计模式之单例模式讲解
08-01
入名所示，该文件为最详细的Java单例模式讲解并附有讲解代码。主要讲了单例模式的几种方法，懒汉模式、饿汉模式、静态内部类模式。着重讲解了懒汉模式下怎么实现线程安全。饿汉模式和静态内部类模式如何设置能够避免...
Java设计模式之单例
12-22
但是Java原生带有的System.out.println()方法却很少在真正的项目开发中使用，甚至像findbugs等代码检查工具还会认为使用System.out.println()是一个bug。 　为什么作为Java新手神器的System.out.println()，到了...
设计模式--单例模式java例子
02-07
设计模式--单例模式java例子
Java单例模式实现静态内部类方法示例
08-29
主要介绍了Java单例模式实现静态内部类方法示例，涉及构造函数私有化等相关内容，需要的朋友可以了解下。
Java设计模式 - 单例模式
探长々
08-25 446
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。单例类只能有一个实例。单例类必须自己创建自己的唯一实例。单例类必须给所有其他对象提供这一实例。在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 712
单例设计模式
java设计模式—单例模式
weixin_46972127的博客
04-18 366
目录 1、什么是设计模式？ 2、什么是单例模式？ 3、单例模式的具体实现方式 3.1 饿汉模式 3.2 懒汉模式 1、什么是设计模式？ 设计模式就好比象棋种的“棋谱”，红方当头炮，黑方马来跳。针对对方的一些招数，己方的一些固定套路。 2、什么是单例模式？ 单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用一个对象且作用相同时，为了防止频繁创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。实现方式：构造方法的
java设计模式--单例模式
qq_39769092的博客
07-26 200
5、懒加载之内部静态类加载（内部静态类，在需要的时候进行初始化，jvm保证线程安全）单例模式在用户需要使用使用一个对象，不论在哪里使用，都是同一个对象。问题多线程访问进行初始化的时候，线程不安全；2、懒汉模式（在使用的时候就完成初始化）6、单例模式之java创始人写法（枚举）1、饿汉模式（类完成加载就完成初始化）4、懒汉模式之双重检查提高效率。...
java设计模式之单例模式
Greetty的博客
08-03 394
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
JAVA设计模式 单例模式
zzh
02-20 233
JAVA设计模式 笔记 单例模式 饿汉式 空间换时间加载模式 SingletonOne.java package com.imooc.singleton; /** * 饿汉式： 创建对象实例直接初始化 */ public class SingletonOne { //1,创建类中的私有构造,类外不能实例，只能通过类名调用 private SingletonOne(){ } //2, 创建该类中的静态私有实例 private static Singl
Java设计模式——单例模式
m0_62946761的博客
01-12 6900
介绍Java设计模式的八种单例模式
Java设计模式之单例模式详解
单例模式（Singleton）是一种常用的设计模式，它的主要目的是确保一个类中只有一个实例，并且该实例必须自动创建，并向整个系统提供该实例。下面我们来详细了解单例模式的定义、结构、优缺点和应用场景。 定义： ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

豪想敲代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值