设计模式（单例模式）

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量113 收藏
点赞数
分类专栏： 设计模式系列 文章标签： java python c++ c语言 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/prefect_start/article/details/104356369
版权

设计模式类型：

设计模式分为三种类型，共23 种：

  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
  2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
  3. 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)。

单例模式

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

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

单例模式有八种方式：

  1. 饿汉式(静态常量)
  2. 饿汉式（静态代码块）
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全，同步方法)
  5. 双重检查
  6. 静态内部类
  7. 枚举
饿汉式(静态常量)

代码如下：

package com.design.models.singleton;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（饿汉式 静态变量）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
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(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、使用静态变量创建对象
    private final static Singleton INSTANCE = new Singleton();
    //3、提供public方法
    public static Singleton getInstance(){
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

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

代码

package com.design.models.singleton;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（饿汉式 静态代码块）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest02{
    public static void main(String[] args) {
        Singleton02 instance = Singleton02.getInstance();
        Singleton02 instance2 = Singleton02.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

//创建对象
 class Singleton02 {
    //1、构造器私有化
    private Singleton02(){
    }
    //2、创建静态变量
    private static Singleton02 INSTANCE;
    //3、在静态代码块中创建对象
    static {
        INSTANCE = new Singleton02();
    }
    //4、提供public方法
    public static Singleton02 getInstance(){
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

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

代码：

package com.design.models.singleton.type1;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（懒汉式 线程不安全）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest03{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、创建静态变量
    private static Singleton INSTANCE;
    //3、提供public方法
    public static Singleton getInstance(){ 
        if (INSTANCE == null){ //判断INSTANCE是否为null  如果为null 则为变量赋值
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

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

代码：

package com.design.models.singleton.type2.type1;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（懒汉式 同步方法 线程安全）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest04{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、创建静态变量
    private static Singleton INSTANCE;
    //3、提供public方法   加锁解决了线程不安全的问题
    public static synchronized Singleton getInstance(){
        if (INSTANCE == null){ //判断INSTANCE是否为null  如果为null 则为变量赋值
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

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

代码：

package com.design.models.singleton.type3;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（双重检查）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest06{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //2、创建静态变量  volatile的作用当别的线程更改变量的值后，会强制更新的主内存中，被其他的线程可见
    private static volatile Singleton INSTANCE;
    //3、提供public方法   
    public static Singleton getInstance(){
        if (INSTANCE == null){ //判断INSTANCE是否为null  
            synchronized (Singleton.class){
                if (INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

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

代码：

package com.design.models.singleton.type04;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（静态内部类）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
public class SingletonTest07{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

    }
}

//创建对象
 class Singleton {
    //1、构造器私有化
    private Singleton(){
    }
    //创建静态内部类   1、类在初始化的时候静态内部类不会同时初始化
    //                2、静态内部类在被调用的时候进行初始化，只会被调用一次 是线程安全的。
    private static class SingletonInstance{
        public static final Singleton INSTANCE = new Singleton();
    }

    //3、提供public方法
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}
//运行结果
//true
//1163157884
//1163157884

优缺点说明：

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

代码：

package com.design.models.singleton.type05;
/**
 * @ClassName : Singleton  //类名
 * @Description : 单例模式（枚举）  //描述
 * @Author : swq  //作者
 * @Date: 2020-02-17 12:56  //时间
 */
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.sayOk();
    }
}

//创建对象
 enum Singleton {
    INSTANCE;
    public void sayOk(){
        System.out.println("ok~");
    }
}
//        true
//        1163157884
//        1163157884

优缺点说明：

  1. 这借助JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
  2. 这种方式是Effective Java 作者Josh Bloch 提倡的方式
  3. 结论：推荐使用
后端技术那点事
关注
专栏目录
Java设计模式之单例模式
Simon学Java
02-09 1176
单例模式是结构最简单的设计模式，在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于被外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。单例模式(Singleton Pattern)定义：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
设计模式单例模式
10-10
单例模式是软件设计模式中的一种基础且广泛应用的模式，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在系统中需要频繁创建和销毁对象，且对象创建成本较高，或者需要共享资源的情况下非常...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
JAVA设计模式之单例模式
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
C++ 设计模式——单例模式
qq_68194402的博客
08-22 2177
单例模式（Singleton Pattern）也称单件模式/单态模式，是一种创建型模式，用于创建只能产生一个对象实例的类。
设计模式——单例模式
qq_51114283的博客
07-11 2352
创建型模式——单例模式
C# 设计模式之单例模式
鲤籽鲲的博客
07-31 1192
C# 设计模式之单例模式
设计模式 —— 单例模式
weixin_44814196的博客
09-04 683
单例模式（Singleton Pattern）是一个比较简单的模式，其定义如下：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
Python设计模式 - 单例模式
mofei
05-04 1012
单例模式是一种创建型设计模式， 其主要目的是确保一个类只有一个实例， 并提供一个全局访问点来访问该实例。
设计模式-01 设计模式单例模式
jxusthusiwen的专栏
04-30 1639
单例模式是一种设计模式，它确保一个类只能被实例化一次。它通过在类内部创建类的唯一实例并提供一个全局访问点来实现这一点。优点：全局访问：单例对象可以从应用程序的任何地方访问。资源节约：它只创建一个对象，从而节省了内存和资源。线程安全性：如果单例对象正确实现，它可以是线程安全的，这意味着它可以在多线程环境中安全地使用。C++11 中的单例模式通过双重检查锁定和 RAII 技术实现线程安全的惰性实例化，确保全局访问和资源管理。在实现上，这比起低版本的来说，预言特性给我们更加灵活的操作性。
js设计模式之单例模式
楠姐的博客
11-09 8008
单例模式也称为单体模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点
设计模式单例模式和工厂模式综合应用
05-25
"设计模式单例模式和工厂模式综合应用"的主题聚焦于两种常用的设计模式：单例模式和工厂模式，并探讨它们如何协同工作来实现高效、灵活的代码结构。这个主题尤其适用于Java编程语言，因为Java的面向对象特性使得设计...
Java设计模式单例模式(Singleton)用法解析
08-25
Java设计模式单例模式（Singleton）用法解析 java设计模式单例模式（Singleton）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局反访问点。单例模式是创建型模式。单例模式在生活中应用也很广泛，...
设计模式单例模式.zip
05-03
单例模式是软件设计模式中的一种经典模式，它在计算机科学中被广泛应用于创建和管理一个类的唯一实例。这个模式的核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一的实例。这样的设计可以避免...
设计模式单例模式PPT学习教案.pptx
10-02
设计模式单例模式学习教案 单例模式概述 单例模式是设计模式中的一种，用于确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。这种模式对对象的创建和访问进行了限制，以确保系统中只有一个实例...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 461
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 956
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 994
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1019
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
李建忠设计模式单例模式
07-16
李建忠设计模式中的单例模式是一种常用的软件设计模式，它的目的是确保一个类只有一个实例，并提供全局访问点。这个模式通常用于管理资源，如数据库连接、线程池、日志系统等，需要在整个应用中保持一致性。 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值