设计模式之单例模式

已于 2022-01-26 09:40:23 修改
阅读量1k 收藏 4
点赞数
文章标签： 单例模式 java
于 2022-01-25 13:00:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54950870/article/details/122683120
版权

目录

单例模式大致介绍

单例模式之饿汉式

静态变量

 静态代码块

单例模式之懒汉式

1)懒汉式（线程不安全）

2) 懒汉式(线程安全，同步方法)

3) 懒汉式(线程安全，同步代码块)

4) 双重检查

5) 静态内部类

6) 枚举

源码中探究单例模式

1)JDK中

 2）Spring框架中

总结：

单例模式大致介绍

相信接触java的小伙伴都对单例模式有一点了解。

单例模式属于创建型模式，其主要为：在一个系统或一个项目中，我们对于某一类对象只创建保存维护一个实例对象。

在我们常用的单例模式主要分为两种，一种是饿汉式，一种是懒汉式。

饿汉式与懒汉式的主要区别为：饿汉式是对象随着类的加载而创建，即一开始便创建好了对象，而懒汉式是指在你调用时才会创建对象。

由其区别，可以分析：

饿汉式的主要优点为：实例是随着类的加载而加载的，故此避免了线程同步问题，而且较为简单；

缺点也很明显：如果没用到懒汉式的这个实例，就会造成内存的浪费。

而懒汉式的优点为：能够充分利用，在调用时才创建。

缺点：就是容易造成线程同步，造成线程不安全问题。

单例模式细分下来，可达8种之多！

饿汉式分为2种，懒汉式分为6种！

单例模式之饿汉式

首先我们对于饿汉式的两种先做介绍。

饿汉式分为静态变量和静态代码块两种。

静态变量顾名思义，就是将对象作为类的静态变量，通过显式赋值的方式，来对对象进行初始化。

静态代码块则是通过静态代码块的形式进行赋值（即创建对象）。

由于不是很难，我便写上代码。

静态变量

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 10:26
 */
//饿汉式1：静态变量
public class Singleton1 {
    public static void main(String[] args) {
        //验证其存在的对象实例是否唯一
        Singleton1 singleton1 = Singleton1.getSingleton1();
        Singleton1 singleton2 = Singleton1.getSingleton1();
        System.out.println(singleton1==singleton2);//true
    }
    //此时的对象是在类的变量中显式创建的
    private static Singleton1 singleton1= new Singleton1();
    //构造器私有是为了防止外界通过new+构造器的方式创建对象
    private Singleton1(){}
    //我们通过对外暴露一个public的方法，供外界获取实例对象
    //这里也符合设计模式原则之迪米特法则，即最小知道原则，尽可能提供少的public方法给外部，把其它不必要的进行隐秘封装
    public static Singleton1 getSingleton1(){
        return singleton1;
    }
}

 静态代码块

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 10:30
 */
//饿汉式1：静态代码块
public class Singleton2 {
    public static void main(String[] args) {
        //验证其存在的对象实例是否唯一
        Singleton2 singleton1 = Singleton2.getSingleton2();
        Singleton2 singleton2 = Singleton2.getSingleton2();
        System.out.println(singleton1==singleton2);//true
    }
    //定义变量，此时不显式赋值
    private static Singleton2 singleton2;
    static {//在静态代码块中创建对象
        singleton2 = new Singleton2();
    }
    //构造器私有是为了防止外界通过new+构造器的方式创建对象
    private Singleton2(){}
    //我们通过对外暴露一个public的方法，供外界获取实例对象
    public static Singleton2 getSingleton2(){
        return singleton2;
    }
}

单例模式之懒汉式

懒汉式共分为六种：

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

我们通过在代码中探究：

1)懒汉式（线程不安全）

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 10:37
 */
//懒汉式（线程不安全）
public class Singleton3 {
    public static void main(String[] args) {
        /*
        分析问题：
        对于本类中的getSingleton3方法，如果多个线程同时进入该方法的if判断，初始大家都会判断singleton3为null
        会导致每个线程都会new一个对象
        因为无法保证该系统中只存在一个实例，故此存在线程不安全的问题
        但是如果是单线程通过，则不存在线程不安全的问题
         */
        System.out.println("=====单线程下====");
        Singleton3 singleton1 = Singleton3.getSingleton3();
        Singleton3 singleton2 = Singleton3.getSingleton3();
        System.out.println(singleton1 == singleton2);
    }

    //创建一个属性变量
    private static Singleton3 singleton3;

    //私有构造器，防止外界new对象
    private Singleton3() {
    }

    //我们通过对外暴露一个public的方法，供外界获取实例对象
    public static Singleton3 getSingleton3() {
        //保证只有一个实例
        if (singleton3 == null) {
            singleton3 = new Singleton3();
        }
        return singleton3;
    }
}

2) 懒汉式(线程安全，同步方法)

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 10:51
 */
/*
对上一种方法的问题分析：
对于本类中的getSingleton3方法，如果多个线程同时进入该方法的if判断，初始大家都会判断singleton3为null
会导致每个线程都会new一个对象
因为无法保证该系统中只存在一个实例，故此存在线程不安全的问题
但是如果是单线程通过，则不存在线程不安全的问题
*/
//懒汉式(线程安全，同步方法)
public class Singleton4{
    public static void main(String[] args) {
        /*
        对于本种方式的问题分析：
        效率太低，每个线程进入getSingleton4方法时，都需要保持同步，在线程外等待
        其实我们并不需要等待，假设发现线程进入了，我们只需要判断singleton4不为空时返回就行了
        因为一旦有线程进入了，我们就知道，有线程在实例化，或者已经实例化完了
        如果实例化完了，后续的线程仍在等待，这样效率是很低了，直接返回对象就可以了
         */
    }
    //创建一个属性变量
    private static Singleton4 singleton4;

    //私有构造器，防止外界new对象
    private Singleton4() {
    }

    //我们通过对外暴露一个public的方法，供外界获取实例对象
    //我们把该方法设置为同步方法，此时即能够避免线程不安全问题
    public static synchronized Singleton4 getSingleton4() {
        //保证只有一个实例
        if (singleton4 == null) {
                singleton4 = new Singleton4();
        }
        return singleton4;
    }
}

3) 懒汉式(线程安全，同步代码块)

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 11:21
 */
//懒汉式(线程安全，同步代码块)
public class Singleton5 {
    /*
    对上一种方法的问题分析：
    效率太低，每个线程进入getSingleton4方法时，都需要保持同步，在线程外等待
    其实我们并不需要等待，假设发现线程进入了，我们只需要判断singleton4不为空时返回就行了
    因为一旦有线程进入了，我们就知道，有线程在实例化，或者已经实例化完了
    如果实例化完了，后续的线程仍在等待，这样效率是很低了，直接返回对象就可以了
    */
    public static void main(String[] args) {
        /*
        对于本次改进的问题分析：
        初始多线程一起进入方法，singleton5的初始值为null，都进了if的判断里面
        一个线程握住锁，其余线程都在外面等待
        当握住线程的锁创建实例完毕之后，换下一个线程握锁，又重新实例化，
        这就导致了线程不安全的问题，故此该方法看似线程安全，实则线程不安全
         */
    }

    //创建一个属性变量
    private static Singleton5 singleton5;

    //私有构造器，防止外界new对象
    private Singleton5() {
    }

    //我们通过对外暴露一个public的方法，供外界获取实例对象
    public static  Singleton5 getSingleton5() {
        //保证只有一个实例
        if (singleton5 == null) {
            //握住类锁
            synchronized (Singleton5.class) {
                singleton5 = new Singleton5();
            }
        }
        return singleton5;
    }
}

4) 双重检查

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 11:32
 */
//双重检查
public class Singleton6 {
    /*
   对上一种方法的问题分析：
   初始多线程一起进入方法，singleton5的初始值为null，都进了if的判断里面
   一个线程握住锁，其余线程都在外面等待
   当握住线程的锁创建实例完毕之后，换下一个线程握锁，又重新实例化，
   这就导致了线程不安全的问题，故此该方法看似线程安全，实则线程不安全
   */
    //创建一个属性变量
    //volatile告诉jvm， 它所修饰的变量不保留拷贝，直接访问主内存中的对象
    private static volatile Singleton6 singleton6;

    //私有构造器，防止外界new对象
    private Singleton6() {
    }

    //我们通过对外暴露一个public的方法，供外界获取实例对象
    /*
    解决方案：
    对属性增添一个关键字volatile
    我们采取双重检查的方式
    握住锁之后，再进行一次空判断，即可达成目的
     */
    public static Singleton6 getSingleton6() {
        //保证只有一个实例
        if (singleton6 == null) {
            //握住类锁
            synchronized (Singleton6.class) {
                if (singleton6 == null) {//在锁里面同样进行一次空判断
                    singleton6 = new Singleton6();
                }
            }
        }
        return singleton6;
    }
}

5) 静态内部类

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 11:40
 */
//静态内部类
public class Singleton7 {
    //创建一个属性变量
    private static volatile Singleton7 singleton7;

    public static void main(String[] args) {
        Singleton7 singleton7 = Singleton7.getSingleton7();
        Singleton7 singleton71 = Singleton7.getSingleton7();
        System.out.println(singleton7==singleton71);//true
        /*
        本方法的原理：
        我们知道，jvm在类加载中，会将其static修饰的变量同样进行加载，
        在Singleton7这个类中，SingletonInstance作为其静态内部类，同样也会被加载
        而SingletonInstance中的属性也会被加载，
        也就是说，SingletonInstance中的属性是单例模式的对象，在类加载阶段就会被初始化，与（1）（2）方法同理
        且因为jvm在加载类中，类只会被加载一次，这也就不存在线程安全问题
        这也就保证了一个实例的情况
         */
    }
    //私有构造器，防止外界new对象
    private Singleton7() {
    }
    //创建一个静态内部类
    static class SingletonInstance{
        //定义一个属性，属性值为单例模式的对象
        //需要加final关键字，防止其值被修改
        private static final Singleton7 INSTANCE  = new Singleton7();
    }
    //我们通过对外暴露一个public的方法，供外界获取实例对象
    public static Singleton7 getSingleton7() {
        return SingletonInstance.INSTANCE;
    }
}

6) 枚举

package singleton;

/**
 * @author liuweixin
 * @create 2022-01-25 11:50
 */
//枚举
public class Singleton8 {
    public static void main(String[] args) {
        /*
        本方法的思想：
        我们通过jdk1.5引入的enum枚举关键字，通过枚举方式实现单例模式
         */
        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance==instance1);//true
    }
    enum Singleton {
        INSTANCE; //属性
    }
}

源码中探究单例模式

1)JDK中

我们可以看到在JDK源码中的Runtime类中就有使用到单例模式的身影，如图即采用了饿汉式的单例模式

 2）Spring框架中

用过spring框架的小伙伴应该都知道，我们在spring的配置文件创建bean对象时，会有这么个配置

 标签中的scope属性，便是指明，通过单例模式来创建该对象。该属性默认值为Singleton，即为单例模式.

通过追溯源码，我们可以看到，在AbstractBeanFactory类中的getBean()方法中调用了getSingleton()方法，即为获取单例对象。

 我们追溯getSingleton()方法，发现其在DefaultSingletonBeanRegistry类中实现，通过观察其实现代码，我们可以得知，spring中的单例模式的获取采用的是上述懒汉式的（4）双重检查的方式。

 再追溯一下，发现getSingleton()方法是定义在一个接口SingletonBeanRegistry()中，而DefaultSingletonBeanRegistry则是实现了该接口，并重写实现了getSingleton()方法，至此，我们可以画出spring中单例模式对应的UML类图:

总结：

饿汉式与懒汉式各有千秋，需要根据具体业务需求采取对应合适的方式，对于饿汉式两种方式都可以使用，对于懒汉式，推荐使用后三种，即4) 双重检查、5) 静态内部类、6) 枚举

注意事项：

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

风嘱
关注
Design Pattem 详解--单例模式
chuli0327的博客
10-15 342
单例设计模式 1.概念： 所谓类的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类，只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法） eg：Hibranate 的 SessionFactory 她充当数据存储源的代理并负责创建Session对象，SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式 2.八种单例模式： ...
Java单例模式--饿汉式、懒汉式
yangyang3_的博客
05-24 215
Java单例模式--饿汉式、懒汉式什么是单例模式单例模式是保证在整个应用程序的生命周期中，在任何时刻，被指定的类只有一个实例。 实现单例模式的思路 1外界不能造对象  --把无参构造方法私有 2类本身要造一个  --调用构造方法即可 3通过公共的方式对外提供       --通过public修饰       --又由于无参构造私有，所以要用static修饰符       --为了保证静态方法只能访...
设计模式---单例设计模式(Singleton Pattern)
weixin_34238642的博客
03-14 106
在学习单例模式之前，首先我们必须明白为何需要单例模式。即单例模式存在的意义。考虑到 这样一种场景：在整个应用中某个类只有一个独一无二的实例，也就是"单例"，例如笔者在以前完 成的一个聊天程序的聊天窗口。有这样一种需求，即是当聊天窗口已经打开的时候不在实例化它。 基于上述描述，单例模式的存在是有其实际意义的！那么，...
单例模式的懒汉式和饿汉式
码疯的专栏
04-21 6919
饿汉式:         public class Singleton{             private static Singleton singleton = new Singleton ();             private Singleton (){}             public Singleton getInstance(){return singletion;
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
c#设计模式之单例模式的实现方式
12-26
单例模式对于我们来说一点也不模式，是一个常见的名称，单例模式在程序中的实际效果就是：确保一个程序中只有一个实例，并提供一个全局访问点，节省系统资源 单例模式无论是在实际开发中还是在软件应用中比较常见，...
C# 设计模式之单例模式归纳总结
08-30
C# 设计模式之单例模式是一种常用的设计模式，它限制了类的实例化，使得某个类只能有一个实例，并提供了一个全局访问点来访问该实例。本文将对单例模式的定义、优缺点、实现要点和适用性进行详细的讲解。 单例模式...
JAVA设计模式之单例模式
最新发布
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
Android编程设计模式之单例模式实例详解
01-04
单例模式是应用最广的模式之一，也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的...
单例的例子与UML图
03-24
单例的例子与UML图,用UML图去记代码,更容易
UML类图学习及单例模式
明哥的博客
10-13 956
https://blog.csdn.net/js_tengzi/article/details/90143246 https://design-patterns.readthedocs.io/zh_CN/latest/read_uml.html https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/singl...
Java模式设计之单例模式, 接上篇【饿汉式，懒汉式】
风流浪子的专栏
11-12 2831
作为对象的创建模式[GOF95]， 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。　　注：本文乃阎宏博士的《Java与模式》一书的第十五章。引言　　单例模式的要点　　单例单例　 　显然单例模式的要点有三个；一是某各类只能有一个实例；二是它必须自行创建这个事例；三是它必须自行向整个系统提供这个实例。在下面的对象图中，有一个 "单例对象"，而"客户甲"
设计模式——单例模式(饿汉式、懒汉式)
weixin_30763397的博客
01-21 111
一、设计模式之单例模式 设计模式：解决每一类问题最行之有效的方法 GOF 23种 java中23种设计模式 单例设计模式：解决一个类在内存中只存在一个对象 想要保证对象唯一： 1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象 2、还为了让其他程序可以访问到该类对象，只好在本类中，定义一个对象 3、为了方便其他程序对自定义...
单例模式懒汉式与饿汉式java讲解
luoshiwutai的博客
04-06 2032
单例模式是常用的设计模式之一，实质就是确保一个类只有一个实例对象，分为懒汉式和饿汉式两种。 类图如下： 一、懒汉式单例模式 1.懒汉式单例模式原始版： 开始设置实例对象为空，只要对象为空的话就返回一个实例对象。 2.懒汉式单例模式优化版（同步方法方式或同步块方式）： 然而如果一个线程进入之后还没有将实例对象赋值之前，又有一个线程进入，这样就会先后创建两个对象，造成多个线程共同抢
单例模式-饿汉式
qq_42424677的博客
05-10 77
package com.ocean.staticpackages.singleton; public class SingleTon01 { public static void main(String[] args) { //通过直接调用返回已经指向对象的对象引用的静态方法去获得类的对象 GirFirend gf = GirFirend.getInstance(); System.out.println(gf); } } class Gi
创建型模式-单例模式、工厂模式
车车的博客
12-10 1065
目录 创建型模式特点 创建型模式分类 单例模式（Singleton Pattern） 单例介绍 代码演示 ①饿汉式（静态常量） ②饿汉式（静态代码块） ③懒汉式（线程不安全） ④懒汉式(线程安全，同步方法) ⑤懒汉式（线程安全，同步代码块） ⑥双重检查 ⑦静态内部类 ⑧枚举方式 单例再探究 优点： 缺点： 适用场景： Java应用 1、spring中的单例 创建型模式特点 关注的问题：创建对象，将对象的创建和使用分离，这样的目的可以降低代码的耦合度 创建型模式分类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值