设计模式01-单例模式Singleton

最新推荐文章于 2024-11-07 00:05:38 发布
最新推荐文章于 2024-11-07 00:05:38 发布
阅读量118 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34628145/article/details/118194353
版权

设计模式01-单例模式Singleton

一、饿汉式

在平时工作中，如果用到单例使用这种就足够了，类加载到内存后，就实例化一个单例，JVM保证线程安全。

优点：简单实用，推荐使用！

缺点：不管用到与否，类装载时就完成实例化，吹毛求疵。你说你不用你写他做什么呢，起程序的时候慢点就慢点呗。

在这里插入图片描述

代码：

/**
 * 饿汉式01
 */
public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        Mgr01 mgr01 = Mgr01.getInstance();
        Mgr01 mgr02 = Mgr01.getInstance();
        System.out.println(mgr01 == mgr02);
    }
}

第二种写法，通过静态语句块写的本质上和01没有区别。

/**
 * 饿汉式02
 * 通过静态语句块写的本质上和01没有区别
 */
public class Mgr02 {
    private static final Mgr02 INSTANCE;

    static {
        INSTANCE = new Mgr02();
    }

    private Mgr02() { };

    public static Mgr02 getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        Mgr02 mgr01 = Mgr02.getInstance();
        Mgr02 mgr02 = Mgr02.getInstance();
        System.out.println(mgr01 == mgr02);
    }
}

二、懒汉式 1.0

在使用的时候判断，如果未存在就初始化，已存在就使用现有的，这样就实现了用的时候装载。但是会出现多线程装载多个的情况。

优点：用的时候装载，不想饿汉一开始就装载。

缺点：多线程会有问题。

代码：

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 */
public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {
    };

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            //用来方便测试出问题
            //睡1毫米，让线程在判断是==null后，有1毫米的时间让别的线程打断
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

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

运行结果

com.zhow.Mgr03@b906e9
com.zhow.Mgr03@3528c9
com.zhow.Mgr03@c39c3d
com.zhow.Mgr03@f075d2
com.zhow.Mgr03@3528c9
com.zhow.Mgr03@f20091
com.zhow.Mgr03@3528c9
com.zhow.Mgr03@107a4d0
com.zhow.Mgr03@c39c3d
com.zhow.Mgr03@174cde1
com.zhow.Mgr03@3528c9
com.zhow.Mgr03@3528c9
com.zhow.Mgr03@184edb
com.zhow.Mgr03@1d68418
com.zhow.Mgr03@1c65632
com.zhow.Mgr03@4b861f
com.zhow.Mgr03@c45a8f
com.zhow.Mgr03@3bf5ac
com.zhow.Mgr03@c4944f

Process finished with exit code 0

三、懒汉式 2.0 synchronized锁对象

在1.0的基础上加synchronized锁，锁定Mgr04.Class，保证线程安全。但是因为加入了synchronized锁会导致效率下降。

优点：线程安全

缺点：加入synchronized锁，每次使用Mgr04对象会先判断锁的状态，导致效率降低。

代码：

public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {
    }

    ;

    public static synchronized Mgr04 getInstance() {
        if (INSTANCE == null) {
            //用来方便测试出问题
            //睡1毫米，让线程在判断是==null后，有1毫米的时间让别的线程打断
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }

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

运行结果：

com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f
com.zhow.Mgr04@c45a8f

Process finished with exit code 0

四、懒汉式 2.0 synchronized锁静态代码块

使用synchronized锁静态代码块妄图通过减小同步代码块的方式提高效率，然后不可行。虽然是提高了效率但是由于在释放锁后没有进行判断导致线程不安全。

优点：减小同步代码块，提高效率

缺点：线程不安全

代码：

public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {
    }

    ;

    public static Mgr05 getInstance() {
        if (INSTANCE == null) {
            //妄图通过减小同步代码块的方式提高效率，然后不可行
            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

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

运行结果：

com.zhow.Mgr05@1a9e02d
com.zhow.Mgr05@1a9e02d
com.zhow.Mgr05@1a9e02d
com.zhow.Mgr05@1a9e02d
com.zhow.Mgr05@1a9e02d
com.zhow.Mgr05@1a9e02d
com.zhow.Mgr05@3bf5ac
com.zhow.Mgr05@3528c9
com.zhow.Mgr05@4b861f
com.zhow.Mgr05@e24daa
com.zhow.Mgr05@1d68418
com.zhow.Mgr05@1c65632
com.zhow.Mgr05@c39c3d
com.zhow.Mgr05@f20091
com.zhow.Mgr05@174cde1
com.zhow.Mgr05@107a4d0
com.zhow.Mgr05@f075d2
com.zhow.Mgr05@4f5086
com.zhow.Mgr05@b906e9

Process finished with exit code 0

五、懒汉式 2.0 synchronized 双重检查

在释放锁后加入判断，保证线程安全

优点：线程安全

缺点：太麻烦了

代码：

public class Mgr06 {
    private static volatile Mgr06 INSTANCE;//防止指令重排 JIT

    private Mgr06() {
    }

    ;

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

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

运行结果：

com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb
com.zhow.Mgr06@184edb

Process finished with exit code 0

六、静态内部类方式 完美

在Mgr07里面定义了一个静态的内部类，静态内部类里面初始化了一个Mgr07。因为Mgr07Holder的INSTANCE的属性是私有的，所以只有Mgr07能访问到。在Mgr07中定义一个getInstance方法返回静态内部类里面的INSTANCE。

装载Mgr07的时候是不会装载Mgr07Holder的，只有调用getInstance的时候才会加载，所以不但实现了懒加载，还实现了线程安全（线程安全是通过JVM的加载Class只加载一次的特性保证的）。

优点：完美

缺点：不是中的完美

在这里插入图片描述

代码：

/**
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 */
public class Mgr07 {
    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

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


}

运行结果：

com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d
com.zhow.Mgr07@c39c3d

Process finished with exit code 0

七、enum 完美中的完美

不仅可以解决线程同步，还可以防止反序列化。

优点：完美中的完美

缺点：过于完美

在这里插入图片描述

代码：

/**
 * 不仅可以解决线程同步，还可以防止反序列化。
 */
public enum Mgr08 {
    INSTANCE;

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

运行结果：

15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802
15758802

Process finished with exit code 0
小昊爱金玉
关注
专栏目录
嵌入式C语言设计模式 --- 单例模式
EmbedIoT Studio
12-29 2320
单例模式（Singleton Pattern）是软件程序设计中最简单的设计模式之一，单例模式在设计模式分类中，是属于创建型模式，它提供了一种创建对象（实例，变量）的最佳实践方式。顾名思义，单例（也叫单件），也就是在整个程序设计中，只存在一个单一的类（C语言中叫“类型”，通常用结构体类型表示），这个类负责创建一个对象（C语言中叫“定义变量”，通常是指结构体变量）
ava常用设计模式-单例模式
08-26
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一实例。 单例模式有多种实现...
设计模式-单例模式（Singleton Pattern）
weixin_60653563的博客
08-22 1383
单例模式。饿汉式单例；懒汉式；枚举式单例；容器式单例；ThreadLocal式单例。
JAVA设计模式--单例模式
JAVA_SR的博客
09-21 761
单例设计模式
设计模式-单例模式（Singleton）
miaoyl的博客
11-03 570
Java 单例模式（Singleton）是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于需要频繁创建和销毁的对象，例如数据库连接、线程池等。
C++设计模式---单例模式
专注
06-08 1148
由于是在编译时确定的初始化，因此这种方式是线程安全的（在C++11及以后的版本中），并且不需要额外的同步机制。然而，在大多数情况下，这些缺点都是可以接受的，因为单例对象通常代表一些重要的系统资源或功能，需要尽早地初始化。通过单例模式可以创建一个缓存管理器，确保只有一个缓存实例存在，并且可以被多个线程共享，方便全局访问和统一管理缓存。当需要对资源进行集中管理，以确保线程安全的访问时，单例模式是一个不错的选择。当实例化一个类的成本较高，而且只需要一个实例时，可以使用单例模式来避免重复实例化的开销。
创建型设计模式-单例模式
Jacks丶的博客
07-21 641
介绍设计模式之单例模式。
设计模式 -- 单例设计模式（Singleton Pattern）
qq_67342067的博客
08-23 1576
单例模式是一个强大且常用的设计模式，适用于那些需要严格控制资源访问和系统开销的场合。合理地使用单例模式不仅能保证数据一致性和节省系统资源，还能提高应用程序的性能和效率。然而，开发者在使用过程中也需警惕其潜在的缺陷，以确保在适当的场景下发挥其最大的效用。
C++设计模式代码--单例模式
ylxwk的博客
12-28 1135
单例模式代码及升级版
【C++设计模式 -- 单例（Singleton）模式】
a1379292747的博客
12-28 1341
单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点，使得程序的各个部分可以共享这个实例。单例模式的主要目的是限制一个类的实例化过程，确保在运行时只能存在一个实例，并提供一种全局访问方式。在单例模式中，通常会将类的构造函数声明为私有的，这样外部代码无法直接实例化该类。然后，通过静态成员函数或静态成员变量来控制实例的创建和访问。如果实例不存在，就创建一个新的实例；如果实例已经存在，就返回已有的实例。
设计模式--单例模式详解
想着百万年薪努力的小赵
04-13 2348
单例模式的定义 单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理等。J2EE标准中的ServletContext，ServletContextConfig等、Spring框架应用中的ApplicationContext、数据库的连接池等也都是单例形式。 饿汉式单例模式 饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没 出
Java面向对象（高级）- 单例(Singleton)设计模式
11-19
总的来说，单例模式是一种强大的设计模式，它在许多场合下都能帮助我们更好地组织代码，控制资源，提高程序的可维护性和可扩展性。在实际开发中，应根据具体需求选择合适的设计模式，以达到最佳效果。
java设计模式-单例.pdf
05-16
### Java设计模式——单例模式详解 #### 一、单例模式概述 单例模式是设计模式中的一个重要组成部分，属于创建型模式之一。其主要作用是确保某个类仅有一个实例存在，并提供一个全局访问该实例的方法。这在很多场景...
js代码-设计模式---单例模式
07-16
单例模式是软件设计模式中的一种经典模式，它在JavaScript编程中被广泛应用，尤其是在大型项目中，用于确保某个类只有一个实例并且提供一个全局访问点。这个模式的主要目标是限制类的实例化次数，以达到节省系统资源...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 567
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1069
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 711
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 158
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
最新发布
HHppGo的博客
11-07 200
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
JavaEE课件：设计模式详解-单例模式
本资料聚焦于设计模式中的单例（SINGLETON）模式，适合学生学习JavaEE课程时参考。单例模式确保一个类只有一个实例，并提供全局访问点，常用于控制资源的共享，如控制打印任务或数据库连接管理。" 在JavaEE开发中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值