第四章 单例模式

已于 2024-04-14 09:01:32 修改
阅读量352 收藏 4
点赞数 1
分类专栏： 设计模式 文章标签： java 单例模式 开发语言 设计模式
于 2018-11-04 20:54:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qushaming/article/details/83719742
版权

单例模式概述：

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

一、为什么要使用单例设计模式？

        当多个线程要操作同一对象，要保证对象的唯一性，以解决实例化过程中只实例化一次。另外在实际应用到的框架中，比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory，这就会使用到单例设计模式。对于需要频繁创建销毁的对象，使用单例模式可以节省内存资源提高性能。

二、解决思路

        1、有一个实例化的过程（只有一次），产生实例化对象。

        2、提供返回实例对象的方法

三、单例模式的分类

单例模式有八种方式及优缺点：
1. 饿汉式（静态常量）

    1）线程安全性：在加载的时候已经被实例化（只有这一次），所以是线程安全的。
    2）性能：没有延迟加载，若长时间不使用或者没有使用过该实例，实例对象会占用资源，造成内存资源浪费，影响性能。

    注：JDK中的Runtime就是饿汉式实现

2. 饿汉式（静态代码块）

    优缺点与饿汉式（静态常量）一样

3. 懒汉式（线程不安全）

    1）线程安全性：只能在单线程下使用，多线程并发情况下不能保证实例对象的唯一性。
    2）性能：实现了懒加载，性能相对饿汉式比较好。

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

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

    1）通过增加synchronized保证了线程安全性。
    2）使用synchronized使得程序退化到了串行执行，降低了性能。

    注：实际开发不推荐使用

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

    1）不能保证线程安全性

    注：实际开发不推荐使用

6. 双重检查

    1）通过synchronized以及DCL保证了线程安全性。
    2）使用懒加载以及DCL，性能比较好。

    注：实际开发推荐使用

7. 静态内部类

    1）通过静态内部类实现懒加载，保证线程安全性，是目前应用比较广泛的一种单例模式。

    注：内部类的特性是，当外部类被装载的时候，静态内部类是不会被装载的，以此实现懒加载。

8. 枚举

    1）同Holder（持有者模式）一样，是目前运用比较广泛的单例模式，大师结晶

四、八种单例模式的代码实现示例

1）饿汉式（可以深入了解JVM ClassLoader的加载机制）
/**
 * 饿汉模式（静态变量）
 * 1.线程安全性：在加载的时候已经被实例化（只有这一次），所以是线程安全的。
 * 2.性能：没有延迟加载，若长时间不使用，实例对象会占用资源，影响性能。
 */
public class HungerySingleton {
    // 在加载的时候就产生实例对象（由ClassLoader加载）
    private static HungerySingleton instance = new HungerySingleton();

    // 实例的属性会占用资源空间
    private byte[] data = new byte[1024];

    // 单例模式构造器必须私有化，外部不能new
    private HungerySingleton {
          
    }

    // 返回实例对象
    public static HungerySingleton getInstance() {
        return instance;
    }

    // 测试20个线程会返回同一个实例对象
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                System.out.println(HungerySingleton.getInstance());
            }).start();
        }
    }
}
2）饿汉式（静态代码块）
/**
 * 饿汉模式（静态代码块）
 * 1.线程安全性：在加载的时候已经被实例化（只有这一次），所以是线程安全的。
 * 2.性能：没有延迟加载，若长时间不使用，实例对象会占用资源，影响性能。
 */
public class HungerySingleton {
  
    private static HungerySingleton instance;

    // 实例的属性会占用资源空间
    private byte[] data = new byte[1024];

    // 单例模式构造器必须私有化，外部不能new
    private HungerySingleton {
          
    }

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

    // 返回实例对象
    public static HungerySingleton getInstance() {
       return instance;
    }

    // 测试20个线程会返回同一个实例对象
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                System.out.println(HungerySingleton.getInstance());
            }).start();
        }
    }
}
3）懒汉式（线程不安全）
/**
 * 懒汉模式
 * 1.线程安全性：多线程并发情况下不能保证实例对象的唯一性。
 * 2.性能：实现了懒加载，性能相对饿汉式比较好。
 */
public class HoonSingleton {
   private static HoonSingleton instance = null;
   
   private HoonSingleton() {

   }

   // 在调用的过程中实例化对象并返回
   public static HoonSingleton getInstance() {
      // 在多线程情况下，一个线程进入了if (null == instance)判断语句块，还未来得及往下执 
      // 行，另一个线程也通过了这个判断语句，这时便会产生多个实例，
      // 所以在多线程环境下不可使用这种方式。
      if (null == instance) {
         instance = new HoonSingleton();
      }
      return instance;
   }

   public static void main(String[] args) {
      for (int i = 0; i < 20; i++) {
         new Thread(()->{
            System.out.println(HoonSingleton.getInstance());
         }).start();
      }
   }
}
4）懒汉式（同步方法）
/**
 * 懒汉模式 + 同步方法
 * 1.线程安全性：通过增加synchronized保证了线程安全性。
 * 2.性能：使用synchronized使得程序退化到了串行执行，降低了性能。
 */
public class HoonSingleton {
   private static HoonSingleton instance = null;
   
   private HoonSingleton() {

   }

   // 在调用的过程中实例化对象并返回(通过synchronized关键字修饰，保证线程安全性)
   public synchronized static HoonSingleton getInstance() {
      if (null == instance) {
         instance = new HoonSingleton();
      }
      return instance;
   }

   public static void main(String[] args) {
      for (int i = 0; i < 20; i++) {
         new Thread(()->{
            System.out.println(HoonSingleton.getInstance());
         }).start();
      }
   }
}
5）懒汉式（同步代码块）
/**
 * 懒汉模式（同步代码块）
 * 不能保证线程安全性。
 */
public class HoonSingleton {
   private static HoonSingleton instance = null;
   
   private HoonSingleton() {

   }

   public static HoonSingleton getInstance() {
      if (null == instance) {
         // 多个线程进来的时候，不能保证线程安全性，可能会创建多个实例
         synchronized (HoonSingleton.class) {
             instance = new HoonSingleton();
         }
      }
      return instance;
   }

   public static void main(String[] args) {
      for (int i = 0; i < 20; i++) {
         new Thread(()->{
            System.out.println(HoonSingleton.getInstance());
         }).start();
      }
   }
}
6）DCL（Double-Check-Locking）
/**
 * 懒汉模式 + DCL 
 * 1.线程安全性：通过synchronized以及DCL保证了线程安全性。
 * 2.性能：使用懒加载以及DCL，性能比较好。
 * 3.CPU在执行过程中有可能导致实例对象中的实例属性（对象）指令重排，引起空指针异常。
 */
public class HoonSingleton {
   private static HoonSingleton instance = null;
   
   private HoonSingleton() {

   }

   // DCL(Double-check-locking)
   public static HoonSingleton getInstance() {
      // 通过synchronized以及两次判断（DCL）保证线程安全性 
      if (null == instance) {
         synchronized (HoonSingleton.class) {
            if (null == instance) {
               instance = new HoonSingleton();
            }
         }
      }
      return instance;
   }

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

        通过volatile避免CPU指令重排导致空指针异常，进一步改良后的代码如下：

/**
 * 懒汉模式 + DCL 
 * 1.线程安全性：通过synchronized以及DCL保证了线程安全性。
 * 2.性能：使用懒加载以及DCL，性能比较好。
 */
public class HoonSingleton {
   // 通过volatile避免CPU指令重排导致控制针异常
   private volatile static HoonSingleton instance = null;
   
   private HoonSingleton() {

   }

   // DCL(Double-check-locking)
   public static HoonSingleton getInstance() {
      // 通过synchronized以及两次判断（DCL）保证线程安全性 
      if (null == instance) {
         synchronized (HoonSingleton.class) {
            if (null == instance) {
               instance = new HoonSingleton();
            }
         }
      }
      return instance;
   }

   public static void main(String[] args) {
      for (int i = 0; i < 20; i++) {
         new Thread(()->{
            System.out.println(HoonSingleton.getInstance());
         }).start();
      }
   }
}
7）Holder（静态内部类）
/**
 * 持有者模式（Holder）
 * 1.通过静态内部类实现懒加载，保证线程安全性，是目前应用比较广泛的一种单例模式
 */
public class HolderDemo {

   private HolderDemo() {

   }

   private static class Holder {
      private static HolderDemo instance = new HolderDemo();
   }

   // 懒加载
   // synchronized
   // <init> 
   // 调用这个方法时，内部类被装载，且只装载一次，所以时线程安全的
   public static HolderDemo getInstance() {
      return Holder.instance;
   }
}
8）枚举式
public enum EnumDemo {
   // 常量，在加载的时候被实例化，且只能实例化一次
   A, B, C, D;

   public static void m1() {
      System.out.println("method");
   }

   public static void main(String[] args) {
      A.m1();
      B.m1();
      C.m1();
      D.m1();
      System.out.println(A.getClass().getName());// 输出结果：EnumDemo
      System.out.println(B.getClass().getName());// 输出结果：EnumDemo
      System.out.println(C.getClass().getName());// 输出结果：EnumDemo
      System.out.println(D.getClass().getName());// 输出结果：EnumDemo
   }
}

改良代码：

public enum EnumSingleton {
   INSTANCE;

   public static EnumSingleton getInstance() {
      return INSTANCE;
   }
}

改良

/**
 * 同Holder（持有者模式）一样，是目前运用比较广泛的单例模式，大师结晶
 */
public enum EnumSingletonDemo {

   private EnumSingletonDemo() {

   }

   private enum EnumHolder {
      INSTANCE;
      private EnumSingletonDemo instance;

      EnumHolder() {
         this.instance = new EnumSingletonDemo();
      }

      private EnumSingletonDemo getInstance() {
         return instance;
      }
   }
   

   public static EnumSingletonDemo getInstance() {
      return EnumHolder.INSTANCE.instance;
   }
}

王哲晓
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
第04章 面向对象（上） 13 单例设计模式
09-12
在Java中，实现单例模式主要有以下几种方式： 1. **饿汉式（静态常量）**：这是最简单的单例实现，它在类加载时就完成了初始化，所以是线程安全的。但是由于类加载时就创建了单例对象，即使没有被使用也会占用内存...
第四章：Spring AOP API 设计模式1
08-03
5. **单例模式（Singleton）**：Spring AOP中的`SingletonTargetSource`保证了每个目标对象只被创建一次，实现了单例模式，确保在整个应用程序中只有一个共享的实例存在，提高了资源利用效率。 6. **适配器模式...
第3章 软件体系结构风格_设计模式_
09-29
1. 创建型模式：如单例模式（确保类只有一个实例）、工厂模式（提供创建对象的接口）、抽象工厂模式（提供创建相关对象家族的接口）等，关注对象的创建过程。 2. 结构型模式：如适配器模式（使不兼容接口之间能协同...
安卓知识小结第一章
04-11
- 单例模式（singleInstance）：类似栈内模式，但整个任务栈只包含该Activity一个实例，防止其他Activity进入。 3. 任务栈：任务栈是按照先进后出（FIFO）原则管理Activity的队列。按回退键时，栈顶的Activity出栈...
深入浅出设计模式第一章中文.zip
05-20
创建型模式关注对象的创建过程，如工厂模式、抽象工厂模式、单例模式、建造者模式和原型模式。结构型模式处理类和对象的组合，如适配器模式、装饰器模式、代理模式、桥接模式、组合模式、外观模式和享元模式。行为型...
golang 接口
m0_70982551的博客
07-24 951
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 515
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 645
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 595
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 366
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 427
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 860
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 100
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 182
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 273
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 871
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Jvm基础（一）
G81948577的博客
07-19 1113
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
mysql表设计
wwwwwww31311的博客
07-23 174
status 状态 java代码中用一个枚举类，比如我的请假表还处于草稿状态，可以是新建态，提交后处于待审批状态，审批完成则是成功态，审批拒绝就是拒绝态。start_time 开始时间 dateTime类型。end_time 起始时间 dateTime类型。employee_id 外键，和员工信息表想管理。type 请假类型，对应一个枚举类，病假，事假。create_time 请假记录的创建时间。如果让你设计一个请假表，如何设计？approve_id 外键。
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 775
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值