设计模式(一)单例模式Singleton,并没有你想的那么简单

最新推荐文章于 2024-02-21 19:06:10 发布
最新推荐文章于 2024-02-21 19:06:10 发布
阅读量337 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42008012/article/details/105524725
版权

文章目录

前言

设计模式是开发中的一柄利剑,有助于提高效率,减少冗余代码,使代码更适应将来业务的变化等.
但在实际项目中,我们要尽量做到"心中有剑,手中无剑",不要被这些条条框框所限制,使用设计模式的目的是为了帮助我们开发,不要让它成为我们的限制/禁锢.

单例模式

下面说的"完美"不一定适用于所有场景,
其他不那么"完美"的方式也未必就一点都不能用,还是要具体问题具体分析.

"完美"的两种方式(都算是懒汉)

懒汉:这个类很懒,只有被用到时才去加载资源,否则不加载资源
饿汉:这个类很饿,程序运行-类被加载时,就加载资源.

使用枚举enum

这是effectice JAVA中提出的,可以说是单例模式最完美的一种实现了,不仅可以从正常使用上保证单例,还能防止反序列化,因为枚举类没有构造方法.
但是我从个人使用习惯上,感觉用枚举类实现单例,怪怪的,不习惯.
我还是喜欢饿汉模式,或者使用内部类方式实现的懒汉.

public enum SingletonTest001 {

    INSTANCE("大黄");
    private String name;

    SingletonTest001(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void say() {
        System.out.println("hello~");
    }

    public static void main(String[] args) {
        // 通过输出hashcode,可以判断其是否是多线程安全的单例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonTest001.INSTANCE.hashCode())).start();
        }
    }
}

使用内部类

这个也是很完美的一种方式,有JVM来帮我保证单例.
众所周知,当一个类被加载的时候,它的内部类是不会被加载的;只有当第一次使用它的内部类时,才会加载内部类.

public class SingletonTest002 {

    private String name = "大黄";

    // 私有化构造方法
    private SingletonTest002() {

    }

	// 内部类,作为一个持有SingletonTest002的容器
    private static class Holder {
        private static final SingletonTest002 INSTANCE = new SingletonTest002();
    }

    public static SingletonTest002 getInstance() {
        return Holder.INSTANCE;
    }

    public String getName() {
        return name;
    }

    public void say() {
        System.out.println("hello~");
    }

    public static void main(String[] args) {
        // 通过输出hashcode,可以判断其是否是多线程安全的单例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonTest002.getInstance().hashCode()))
                    .start();
        }
    }
}

其他实现方式

饿汉方式

饿汉很简单,直接,干脆,在一些我们知道它一定会被用到的类,我觉得直接用饿汉方式更好.
JVM只会加载一次类,在类加载的时候初始化静态变量.

public class SingletonTest003 {

    public static final SingletonTest003 INSTANCE = new SingletonTest003();

    private String name = "大黄";

    // 私有化构造方法
    private SingletonTest003() {

    }

    public String getName() {
        return name;
    }

    public void say() {
        System.out.println("hello~");
    }

    public static void main(String[] args) {
        // 通过输出hashcode,可以判断其是否是多线程安全的单例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonTest003.INSTANCE.hashCode()))
                    .start();
        }
    }
}

一个懒汉的错误示范(无锁,线程不安全)

上面那个懒汉方式,有人觉得不优雅,有些类根本用不到还加载资源,浪费内存,然后就想了个办法,getInstance时先判断有没有初始化,没有初始化过就去初始化,然后返回实例.

下面这样写在单线程环境下没问题,如果是多线程并发访问的话,就可能不会是真的单例了;
加入线程t1和t2同时调用getInstance()方法,他俩都判断INSTANCE == null为true,就各自都加载资源去了,造成资源浪费或者严重的不易察觉的错误.

public class SingletonTest004 {

    private static SingletonTest004 INSTANCE;

    public static SingletonTest004 getInstance() {
        if (INSTANCE == null) {
            // 模拟加载资源的过程,初始化比较慢
            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new SingletonTest004();
        }
        return INSTANCE;
    }

    private String name = "大黄";

    // 私有化构造方法
    private SingletonTest004() {

    }

    public String getName() {
        return name;
    }

    public void say() {
        System.out.println("hello~");
    }

    public static void main(String[] args) {
        // 通过输出hashcode,可以判断其是否是多线程安全的单例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonTest004.getInstance().hashCode()))
                    .start();
        }
    }
}

方法上加锁的懒汉

上面那个线程不安全的问题,有人很快想到答案了,加锁就是了嘛!
但是加锁是需要额外消耗资源的,这里如果多线程下getInstance调用比较频繁,还是很消耗资源的.

public class SingletonTest004 {

    private static SingletonTest004 INSTANCE;

    public static synchronized SingletonTest004 getInstance() {
        if (INSTANCE == null) {
            // 模拟加载资源的过程,初始化比较慢
            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new SingletonTest004();
        }
        return INSTANCE;
    }

    private String name = "大黄";

    // 私有化构造方法
    private SingletonTest004() {

    }

    public String getName() {
        return name;
    }

    public void say() {
        System.out.println("hello~");
    }

    public static void main(String[] args) {
        // 通过输出hashcode,可以判断其是否是多线程安全的单例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonTest004.getInstance().hashCode()))
                    .start();
        }
    }
}

一个懒汉的错误示范(锁代码块,单次判断,线程不安全)

既然锁加在方法上,会消耗很多资源,那就想着:先判断一次,只有加载资源时候加锁,以后判断就不加锁了.

下面这个例子有很大问题,假设还未实例化,很多个线程同时访问getInstance,大家都判断INSTANCE == null为true了,然后排着队一个个的去加载资源,实例化,没有解决问题.

public class SingletonTest006 {

    private static SingletonTest006 INSTANCE;

    public static SingletonTest006 getInstance() {
        if (INSTANCE == null) {
            // 模拟加载资源的过程,初始化比较慢
            synchronized (SingletonTest006.class) {
                try {
                    Thread.sleep(100L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new SingletonTest006();
            }
        }
        return INSTANCE;
    }

    private String name = "大黄";

    // 私有化构造方法
    private SingletonTest006() {

    }

    public String getName() {
        return name;
    }

    public void say() {
        System.out.println("hello~");
    }

    public static void main(String[] args) {
        // 通过输出hashcode,可以判断其是否是多线程安全的单例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonTest006.getInstance().hashCode()))
                    .start();
        }
    }
}

双重检验锁Double Check Lock

这里要注意,一定要加volatile关键字,防止指令重排序.
这个算是没啥问题的懒汉了,但是感觉略复杂,不那么优雅…

public class SingletonTest007 {

    private static volatile SingletonTest007 INSTANCE;

    public static SingletonTest007 getInstance() {
        if (INSTANCE == null) {
            // 模拟加载资源的过程,初始化比较慢
            synchronized (SingletonTest007.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(100L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new SingletonTest007();
                }
            }
        }
        return INSTANCE;
    }

    private String name = "大黄";

    // 私有化构造方法
    private SingletonTest007() {

    }

    public String getName() {
        return name;
    }

    public void say() {
        System.out.println("hello~");
    }

    public static void main(String[] args) {
        // 通过输出hashcode,可以判断其是否是多线程安全的单例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonTest007.getInstance().hashCode()))
                    .start();
        }
    }
}
君陌先生
关注
专栏目录
c++-设计模式之单例模式（Singleton Pattern）
09-18
单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于需要全局共享资源的场景，比如配置管理、日志记录等。 单例模式的组成 私有构造函数：防止外部...
设计模式之原型模式（java代码实现）
田野上的风筝
12-17 753
简述 原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口（在java中实现Cloneable），，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。还有在spring中的bean的scope中就有使用到原型模
单例模式Double-Checked
人生就像一场戏
11-17 1468
这里主要用Double-Checked和Volatile实现单例模式（双重检查锁定模式） DCL单例模式: 懒汉式套路基础上加入并发控制，保证在多线程环境下，对外存在一个对象 1、构造器私有化 --&gt;避免外部new构造器 2、提供私有的静态属性 --&gt;存储对象的地址 3、提供公共的静态方法 --&gt; 获取属性 public class DoubleC...
单例模式-DoubleCheck
Brain的博客
07-29 4734
1.单例模式理解：是为了满足一些场景，一个对象只能创建一个实例对象的场景。 流程： 1.构造方法私有化， 2.声明对象 位静态 3.类方法返回实例化后的对象。 2.将单例模式分为两类 懒汉式和饿汉式： 懒汉式：特点在定义Singleton是就new public class Singleton{ private static Singleton singleton=new Singleton...
单例模式double-check思想
qq_33499943的博客
05-25 745
转自：http://devbean.blog.51cto.com/448512/203501 在GoF的23种设计模式中，单例模式是比较简单的一种。然而，有时候越是简单的东西越容易出现问题。下面就单例设计模式详细的探讨一下。 所谓单例模式，简单来说，就是在整个应用中保证只有一个类的实例存在。就像是Java Web中的application，也就是提供了一个全局变量，用处相当广泛，比如保存全局数据，实现全局性的操作等。 1. 最简单的实现 首先，能够想到的最简单的实现是，把类的构造...
单例模式【2】---douleCheck（双重检测）详解
开心博客
09-13 2838
本文主要讲述单例模式中doublecheck的介绍
常见设计模式—单例模式(Singleton)
12-22
单例模式是软件设计中的一种常用模式，它的核心思想是限制类的实例化，确保一个类在整个应用程序中只有一个实例存在。这种模式通常用于管理共享资源，如数据库连接、缓存或者全局配置等，以提高效率和减少资源消耗。...
Java设计模式单例模式(Singleton)用法解析
08-25
java设计模式单例模式（Singleton）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局反访问点。单例模式是创建型模式。单例模式在生活中应用也很广泛，比如公司CEO只有一个，部门经理只有一个等。...
php设计模式 Singleton(单例模式)
12-19
单例模式是软件设计模式中的一种，其主要目的是确保一个类只有一个实例，并提供一个全局访问点，以便在程序的任何地方都可以方便地获取这个唯一实例。这种模式在PHP编程中非常常见，特别是在需要管理和共享资源时，...
单例模式 - 双重检查锁定（Double-Checked Locking）
最新发布
qq_44960878的博客
02-21 2642
介绍单例模式、双重检查锁定（double-checked locking）
Eureka源码-double check单例模式运用
qq_35459686的博客
06-18 460
double check，也叫双重检测，主要利用两次的判断进行校验当前单例的创建情况。如下面的代码 首先第一层是instance == null , 他主要的作用是减少synchornized锁竞争的压力，避免在大量线程访问的情况下，导致锁升级为重量级锁，从而导致线程之间互斥而进行长时间堵塞，严重的甚至可能导致OOM的情况。所以加第一层可以有效的阻挡部分已经获取单例的线程再次进入，减少线程间锁的竞争压力。 第二层： 主要是保证在获取锁后的线程确保实例是空的情况下在进行创建，保证了单例仅创建了一次。
懒汉单例模式（double check，静态内部类，枚举的写法）
javaergogoing的博客
03-28 997
单例模式：double check的缺点，静态内部类的缺点，effective java推荐的枚举类写法
设计模式-单例模式中的double-check
suyinfan的博客
04-13 610
单例模式中的double-check 单例模式一般有两种模式：饿汉模式和懒汉模式 1.饿汉模式：程序启动的时候，由主线程创建一个对象实例。 2.懒汉模式: 程序启动的时候，不创建对象(NULL)，如果有两个线程先后执行if(NULL == ms_Singleton)获取对象，那么将创建两份实例。要解决该问题，需要上锁。 经典的单例模式代码如下： template <typename T&g...
单例模式
u012437323的专栏
06-12 227
1.饿汉模式 缺点：当加载该类时，静态方法也会被加载并生成一个对象占用内容，而这个对象不一定会使用，造成资源浪费；另外new SinletionTest()也无法获取构造函数异常；public class SingletonTest { private SingletonTest(){} private static final SingletonTest instance = n
Double-Check实现单例模式
CCC的博客
09-10 1201
Double-Check提供了一种高效的数据同步策略，那就是首次初始化时加锁，之后则允许多个线程同时执行getInstance方法的调用来获得类的实例。示例代码如下： public final class Singleton { private static Singleton instance = null; private Singleton() { } ...
记单例模式double check的正确写法及相关思考
qq_36101933的博客
09-26 1537
今天读了一篇关于单例模式中Double Check的文章，初始有些疑惑，后来串起来一些知识，理一下对单例模式的一点理解。 单例模式要求对象在全局范围内只能存在一个，故此实现单例模式有三个重要的点： 构造方法私有化，保证此类不能外部初始化； 静态并且私有的单例对象，保证此对象内部初始化时只有一个； 静态并且公有的获取单例对象方法， 保证对外提供此单例的获取途径； 以下为最简单的单例模式实现方法（...
为什么单例模式需要double check
weixin_33778544的博客
09-10 869
2019独角兽企业重金招聘Python工程师标准>>> ...
Java单例模式优化写法
diweikang的博客
05-09 1211
方法一：推荐 public class SingletonClass { private static class SingletonClassInstance { private static final SingletonClass instance = new SingletonClass(); } public static SingletonClass...
7中单例模式实现小结
weixin_30247307的博客
03-26 72
import java.net.Socket; import java.sql.Connection; public class Test { public static void main(String[] args){ } } /* 第14章 7中单例设计模式的设计 评估标准：线程安全、高性能、懒加载 */ /* ...
Java设计模式详解：单例模式(Singleton)的应用与实现
"Java设计模式单例模式(Singleton)用法解析" Java设计模式中的单例模式（Singleton Pattern）是一种创建型设计模式，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这个唯一实例可以在整个应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值