单例模式Singleton

已于 2023-03-01 17:21:44 修改
阅读量478 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 单例模式 开发语言 Java
于 2020-11-19 15:52:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36091079/article/details/109814771
版权

文章目录

前言

当在搜索引擎输入"单例模式"这四个字，我们一定可以看到五花八门关于单例模式的分类，最常见的莫过于饿汉式和懒汉式，还有什么5种的，6种，7种的。学习设计模式的过程中不断的深入理解面向对象的思想，灵活地运用到解决实际问题的场景下，这才是我们所需要的。

单例模式(Singleton Pattern)

单例模式Singleton就是某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
单例模式属于创建型模式，它提供了一种创建对象的最佳方式。

1.单例类只能有一个实例。
2.必须保证自己创建自己的唯一实例。
3.并且给其他对象提供访问这一实例的方式。

应用场景

1.要求生产唯一序列号。
2.WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3.创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

分类

单例模式常见的有饿汉式、懒汉式、双检锁/双重校验锁、静态内部类、枚举。

饿汉式

这种方式类加载到内存后，就实例化一个单例，JVM会保证线程安全。简单实用，相当推荐使用。但是，他的唯一缺点就是：不管是否用到，类加载时就会完成实例化。

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

    private Singleton01() {
    }

    public static Singleton01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Singleton01 s1 = Singleton01.getInstance();
        Singleton01 s2 = Singleton01.getInstance();
        System.out.println(s1 == s2);
    }
}

对于饿汉式的单例模式，还有一种是在静态代码块中进行new一个单例。和上面的本质没有区别，看看就好。

public class Singleton02 {
    private static final Singleton02 INSTANCE;

    static {
        INSTANCE = new Singleton02();
    }
    //...
}

懒汉式（线程不安全）

相比饿汉式，懒汉式的单例模式达到了按需初始化的目的，但是带来了线程不安全的问题。

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

    private Singleton03() {
    }

    public static Singleton03 getInstance() {
        if (INSTANCE == null) {
//            try {
//                Thread.sleep(1);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            INSTANCE = new Singleton03();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

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

上面这种方式线程不安全，在判断INSTANCE == null的后面我们把线程阻塞1ms，运行后通过比较hashCode就会发现不同线程访问到的实例并不全是同一个对象实例。

422057313
503674368
1650594751
1634218452
1160999711
1341620907
1522804050
72786614
1430746659
966186071
1133046463
151286434
2115147268
1326204679
422057313
796465865
796465865
733365800
796465865
796465865
...

懒汉式（线程安全）

为了保证懒汉式单例模式线程安全，考虑到对getInstance()方法的改造。通过synchronized来实现线程安全。

/**
 * 可以通过synchronized解决，但却带来了效率下降
 */
public class Singleton04 {
    private static Singleton04 INSTANCE;

    private Singleton04() {

    }

    public static synchronized Singleton04 getInstance() {
        if (INSTANCE == null) {
//            try {
//                Thread.sleep(1);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            INSTANCE = new Singleton04();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

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

运行测试之后，发现这种方式可以保证线程安全。但是在内存当中的对象一定比我们上面这个简单的Singleton04对象大的多，还有就是在每一次使用的时候都需要去获取这把锁才可以获取实例。这样一来，效率就会降低。
所以就有人想通过减少同步代码块的方式来提高效率，所有就产生了下面这种。

/**
 * 通过synchronized解决，但却带来了效率下降。所以就想通过减少同步代码块的方式来提高效率，但是不可行。
 */
public class Singleton05 {
    private static Singleton05 INSTANCE;

    private Singleton05() {

    }

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

    public void m() {
        System.out.println("m");
    }

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

上面这种并不能保证线程安全。所以就出现了双检锁。

双检锁/双重校验锁

双检锁/双重校验锁（DCL，即 double-checked locking）这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

/**
 * 双检锁/双重校验锁
 */
public class Singleton06 {
    private static volatile Singleton06 INSTANCE;//JIT

    private Singleton06() {

    }

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

    public void m() {
        System.out.println("m");
    }

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

静态内部类方式

只有第一次调用getInstance()方法时，虚拟机才加载Singleton07Holder内部类 并初始化INSTANCE，只有一个线程可以获得对象的初始化锁，其他线程无法进行初始化，保证对象的唯一性。

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

    }

    private static class Singleton07Holder {
        private final static Singleton07 INSTANCE = new Singleton07();
    }

    public static Singleton07 getInstance() {
        return Singleton07Holder.INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

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

枚举单例模式

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

    public void m() {
    }

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

结束语

文末就不聊单例了。

耀耀zz
关注
专栏目录
单例模式的学习
猿生之路
03-29 205
一、什么是单例模式？ 单例模式是很常见的一种设计模式，确保某个类只有一个实例，而且它能够自行实例化并且向整个系统提供这个实例。它的作用是在一个jvm中只能存在一个实例，保证对象的唯一性。它的应用场景有很多，像servlet、spring、struts2、springMVC、连接池、线程池、枚举、常量等都是使用的单例模式。 二、单例模式的特点？ 1、单例类只能实例化一次；...
单例模式 Singleton Pattern
03-09
### 单例模式 Singleton Pattern #### 概述 单例模式是一种常见的设计模式，属于创建型模式之一。这种模式的核心在于确保某个类只有一个实例存在，并且提供一个全局访问点来获取该实例。单例模式在Java开发中尤其...
设计模式之单例模式
星空下的程序猿
12-30 727
1 引子 单例模式是指某个类有唯一的实例。 最常见的获取单例的方法有两种：饿汉式和懒汉式。 懒汉式单例模式： public class Single1 { private static Single1 single1; private Single1(){} public static Single1 getInstance(){ if (single1 == n...
Java中的单例模式
weixin_33826268的博客
04-30 88
单例模式是指某个类只能被实例化一次，用来表示全局或系统范围的组件，常用于日志记录，工厂，平台组件管理等。单例模式看似简单实际很难。 单例本身有多种实现方法，总体上可分为懒汉模式和饿汉模式两种，懒汉模式相对简单 public class FooSingleton { public final static FooSingleton INSTANCE = new FooSinglet...
单例模式
Arry
08-31 256
单例模式 在Spring的设计中，使用了很多设计模式，其中，我们最熟悉的应该就是单例模式了。单例模式是指一个类只有一个实例，Spring容器中，所有bean默认都是单例的。比如我们最常写的controller，无论你创建多少个实例，它的方法以及整个执行链都是一样的。  使用单例模式的优点就是可以节省内存空间，减少GC的消耗。 以下给出几种单例模式的实现方法 最简单的实现： 这种实现方...
单例 模式 singleton
01-21
单例模式是一种设计模式，用于确保一个类在整个应用程序中只存在一个实例。这种模式在Java中广泛应用于需要全局访问点或资源管理的场景，比如配置管理、数据库连接池等。下面将详细阐述单例模式的实现方式、优化策略...
Android开发：深入理解单例模式Singleton
"这篇文档详细解析了Android开发中的单例模式Singleton，旨在帮助开发者理解如何在Android环境中应用这种设计模式。文档首先介绍了设计模式的基本概念，然后深入探讨了单例模式的用途和解决的问题，接着通过一个具体...
Java单例模式
绯火琉瞳的专栏
09-15 482
单例模式： 一个类只能有一个实例（每次实例化这个类时获得同一个实例）； 这个实例是唯一的，故建在内部； 整个系统都可以来获取这一实例。 单例模式主要保证在java应用程序中，一个类只有一个实例存在。 public class Singleton { //私有声明 private static Singleton singleton=null; /** * 私有构造函数
单例模式Singleton某个类只需要一个类实例
ninichenchen的专栏
03-05 153
保证一个类只有一个实例，并提供一个访问它的全局访问点。 懒汉式和饿汉式 懒汉式 public class Singleton { private static Singleton instance = null; private Singleton() { } public static synchronized Singleton getInstan...
Java设计模式——单例模式
qq_24442769的博客
03-20 234
概述 单例模式：确保某个类只有一个实例，并自行实例化向整个系统提供这个实例 实现单例模式的关键点： 构造函数不对外开放，一般为private 通过一个静态方法或者枚举返回单例类对象 确保单例类的对象有且只有一个，尤其在多线程环境下 确保单例类对象在反序列化时不会重新构建对象 通过将单例类的构造函数私有化，使得代码不能通过new的形式手动构造类对象，单例类会暴露一个公有静态方法来获...
JavaSE复习——单例模式
Serenity0614的博客
02-25 247
单例模式是指，某个类只能被实例化一次，在JVM中，只能有一个相应的对象存在。 第一种实现方式：饿汉式   package hungry; public class HungryMode { private HungryMode(){ //构造方法私有，以防外部通过new来实例化 } private static HungryMode instance = new Hungr...
JavaSE第二十五讲：单例模式详解
AHuier_Techblog ：如果我不在写代码，你就 @me
11-18 1253
public interface InterfaceTest{ int a; } 执行结果： D:\src>javac InterfaceTest.java InterfaceTest.java:2: 错误: 需要=         int a;              ^ 1 个错误 【说明】:表示接口当中必须给其赋值。 public interface Interfa
设计模式（二）---单例模式
sakurakider的博客
09-04 285
吐槽 今天操作系统上课第一天，自己就腰间盘吐出了，被老师记住了，尴尬啊啊啊啊，以后周末还是把这周学的操作系统好好总结下，不然就完了啊啊啊。 参考资料《Android源码设计模式》 什么是单列模式 确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例 这个可能是我之前写项目时候唯一用到的设计模式，写2048游戏的时候就用过这个，不过当时没想这么多。 应用场景 确保某个类...
设计模式知识点整理-单例模式（饿汉，懒汉）
马小方的博客
04-20 250
定义 单例模式是指某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。 实现思想 在类的内部通过构造一个private的构造方法，外部不能调用其构造方法，所以外部无法实例化。 单例模式有以下特点 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。 单例模式分为饿汉式和懒汉式两种 饿汉就是类一旦加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

耀耀zz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值