设计模式（1）Singleton单例模式_8种写法

最新推荐文章于 2022-04-21 23:38:19 发布
最新推荐文章于 2022-04-21 23:38:19 发布
阅读量591 收藏
点赞数
分类专栏： 重新学习Java 设计模式 文章标签： Java 设计模式 JVM 反序列化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51550750/article/details/124081205
版权

使用场景

内存中只需要一个实例
• 比如各种Mgr
• 比如各种Factory

一共有8种写法，但是只有2种写法是完美无缺的。

写法一：饿汉式（最常见的写法，很实用）

保证只有一个实例—》定义一个静态的实例Instance

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全，
 * JVM保证每一个class在load到内存中，只是load一次--->static变量是在load到内存之后，马上就进行初始化一次，就初始化这一次，多线程也没有关系
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就马上完成实例化
 * Class.forName("") ----加载一个类，只是把class放到内存中，但是不对其进行实例化
 * （话说你不用的，你装载它干啥）
 */
public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};  //构造方法是private，使得别的类无法new --->只有一个实例

    public static Mgr01 getInstance() {  //别人要想使用，必须要调用这个方法---》所以就只有这一个实例
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2); //true
    }
}

写法二：和第一个是一个意思

/**
 * 跟01是一个意思
 */
public class Mgr02 {
    private static final Mgr02 INSTANCE;
    static { //静态语句块
        INSTANCE = new Mgr02();
    }

    private Mgr02() {};

    public static Mgr02 getInstance() {
        return INSTANCE;
    }

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

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

写法三：lazy loading

也叫懒汉式，什么时候使用，什么时候初始化

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题（具体来说就是多线程访问的时候会有影响）
 */
public class Mgr03 {
    private static Mgr03 INSTANCE;  //一开始INSTANCE不进行初始化

    private Mgr03() {    //private导致没法new
    }

    public static Mgr03 getInstance() {   //getInstance是初始化的方法
        if (INSTANCE == null) {
            try {  //测试多线程访问的问题，其实多线程访问的时候又可能创建多个Mgr03（实例化了多个）
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();   //判断INSTANCE为空，就初始化
        }
        return INSTANCE; //如果INSTANCE不为空，就不再初始化，仍旧用原先的那个实例
    }

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

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {  //创建100个线程
            new Thread(()->               //Java8的lambda表达式
                System.out.println(Mgr03.getInstance().hashCode())   //不同对象hashcode是不同的
            ).start();   //不写lambda的话，需要在new Thread()时传入一个new Runnable,其中重写run方法（匿名内部类）
        }
    }
}

补充：lambda表达式就是只有一个方法 的匿名内部类（接口）的对象

说一下上面的执行结果：很多线程的getInstance的哈希值都是相同的，理论上来说应该是不一样的，但是因为线程执行速度过快，所以导致很多hashcode的值都相同，为了模拟实际情况才加入了上面的try-catch来演示结果。（哈希值相同也有可能不是同一个对象）

同一个类的不同对象其哈希值是不同的。上面其实不打印hashCode而直接打印地址也可以

特别注意：最一开始定义的private static Mgr03 INSTANCE; 不能加final因为加了final必须要初始化。

写法四：懒汉式（加锁synchronized）

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 解决：可以通过synchronized解决，但也带来效率下降
 */
public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {
    }

    public static synchronized Mgr04 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr04();
        }
        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(Mgr04.getInstance().hashCode()); //输出的是相同的哈希值
            }).start();
        }
    }
}

static synchronized锁定的是Mgr04.class对象

写法4相对于写法3就多了一个static synchronized，别的没有增加

但是这种方法也有缺陷：内存中的对象比这个大得多，每次用的时候，都要申请锁，加锁，效率就低了。

写法5：

妄图通过减小同步代码块的方式提高效率，然后不可行

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过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 void m() {
        System.out.println("m");
    }

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

这种方法并不能保证在多线程访问的时候做到只有一个实例！！
原因：锁的范围太小（不够“原子性”，在if判断的时候和下面加锁的地方多线程访问，导致创建了多个实例）

写法6:双判断（双重检查）

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT（这个编译器把Java语言直接编译城本地语言），注意要加上volatile，因为这个牵扯到Java虚拟机内部执行的时候汇编语言的优化（语句重排，指令重排，这个会非常频繁），不加volatile会使得没有初始化的时候就返回INSTANCE

    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 void m() {
        System.out.println("m");
    }

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

这种写法是不会出问题的，很完美

写法7：静态内部类方式（完美）

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

    private Mgr07() {
    }

    private static class Mgr07Holder {    //静态内部类，在加载Mgr07的时候，没有初始化这个静态内部类的，这就是优于写法1的地方。只有在调用getInstance方法时，才会加载这个内部类（懒加载也能实现）
        private final static Mgr07 INSTANCE = new Mgr07();  //初始化Mgr07
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;  //返回的是静态内部类中的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(Mgr07.getInstance().hashCode());
            }).start();
        }
    }
}

上面方法为什么线程安全？是JVM帮我们搞定的。虚拟机在加载一个class的时候只会加载一次。

写Java的大牛还出过一本书叫做“Effective Java”，书中写到了一个单例的写法，就是下面的写法8：

写法8：完美中的完美——枚举单例

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

    INSTANCE;

    public void m() {}

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

}

实际应用中，其实写法1就够了，没必要追求不必要的完美。

关于序列化和反序列化

Java的反射可以通过一个class文件将整个class load到内存，然后再new一个实例出来---->反序列化，“不可阻挡”

为了防止反序列化，当然用写法8是能够解决这个问题的（网安中有严重 的反序列化漏洞，简单来说一些白帽子或者一些黑客可能会利用反序列化漏洞）。

写法8之所以能够避免反序列化漏洞是因为这个类（枚举类）没有构造方法。所以说写法8是最完美的方法。但是实际中确实方法1用的最多。因为明明应该是一个类，好好的把它搞成枚举，确实有点让人觉得奇怪了。

单例总结

语法上最完美的是写法8，但是实际中用的最多的是写法1

qq_51550750
关注
专栏目录
设计模式-Singleton单例模式详解以及8种写法
huangqingfeng的博客
04-22 512
什么是单例模式 单列模式是保证在内存之中只有一个实例 单列模式的八种写法 第一种写法饿汉式 类加载到内存后，就实例化一个单例，JVM保证线程安全。简单实用，推荐使用！缺点：不管用到与否，类装载时就完成实例化 public class Mgr01 { private static final Mgr01 INSTANCE = new Mgr01(); private Mgr01() {}; public static Mgr01 getInstance() {
Java设计模式单例模式(Singleton)用法解析
08-25
Java设计模式单例模式（Singleton）用法解析 java设计模式单例模式（Singleton）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局反访问点。单例模式是创建型模式。单例模式在生活中应用也很广泛，...
Singleton模式——设计模式学习
weixin_33728708的博客
01-04 109
　　　　　　Singleton 一 意图 　　保证一个类仅有一个实例，并提供一个访问的全局访问点。 二 结构        为什么需要仅有一个类的单例类呢？在很多种情况下，一个系统只需要此类的一个实例就够了：一个窗口管理器，一个消息通知器，一个数据存储器……        有时候只能有一个：系统共用一个存储器，很多地方访问到存储器，必须要保证存储器唯一。 三 代码实现 cla...
设计模式-Singleton模式（只有一个实例）
Xminyang的博客
07-08 738
顾名思义，单例模式也就是在任何情况下都绝对只有一个实例。 Singleton模式对实例的数量就行限制的原因是：当存在多个实例时，实例之间会相互影响，可能会产生意想不到的的Bug；如果此时，能够确保有且只有一个实例，就可以在这个前提下放心编程了。 以下面的程序为例，进行简单的说明：package GoF; /** * 单例模式 * @author xminyang * */ public
创建设计模式 - Singleton设计模式（最佳实践与示例）
YunWisdom
01-01 452
Java Singleton设计模式最佳实践与示例 Java Singleton Pattern是四种帮派设计模式之一，属于创建设计模式类别。从定义来看，它似乎是一个非常简单的设计模式，但是当涉及到实现时，它会带来很多实现问题。Java Singleton模式的实现一直是开发人员争议的话题。在这里，我们将了解Singleton设计模式原理，实现Singleton设计模式的不同方...
设计模式-Java Singleton设计模式最佳实践与示例（单例模式）
iSelenium
02-25 303
Java Singleton Pattern是四种帮派设计模式之一，属于Creational Design Pattern类别。从定义来看，它似乎是一个非常简单的设计模式，但是当涉及到实现时，它会带来很多实现问题。Java Singleton模式的实现一直是开发人员争议的话题。在这里，我们将了解Singleton设计模式原理，实现Singleton设计模式的不同方法以及一些使用它们的最佳实践。 ...
Java设计模式之单例模式的七种写法
07-13
Java设计模式之单例模式的七种写法 单例模式是一种常见的设计模式，它确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机的驱动程序对象常...
JavaScript设计模式之单例模式详解
12-11
这一次重温一下《JavaScript设计模式与开发实践》，开篇为单例模式。 /** * pre 单例模式 * 定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点 * 应用：单例模式是一种常用的模式，有一些对象我们...
Java：单例模式的七种写法
12-22
免线程同步问题，而且还能防止反序列化重新创建新的对象，绝对的线程安全，同时也能保证单例的唯一性。...同时，单例模式也常常与其他设计模式结合使用，如工厂模式、建造者模式等，以解决更复杂的问题。
【Singleton】写一个单例设计模式
Skyline_ding的博客
11-25 441
一.要点： 1.某个类 只能有一个实例：构造器私有化 2.必须自行创建这个实例:含有一个该类的静态变量来保存这个唯一的实例 3.必须自行向整个系统提供这个实例: 对外提供获取这个实例对象的方式 a.直接暴露 b.用静态变量的get方法获取 二.常见形式： 1.饿汉式：在类初始化时直接创建对象，不存在线程安全问题 1):直接实例饿汉式 public class Singleton { public static final Singleton INSTANCE=new Singl.
大话设计模式--Singleton(单例模式)
03-28
NULL 博文链接：https://linxingliang.iteye.com/blog/1217811
Java设计模式——单例模式
海边小男孩的博客
12-03 206
java设计模式——单例模式 单例模式是一种比较简单常见的设计模式，属于创建型模式的一种，单例模式的写法有好几种，这里主要介绍二种：饿汉式单例、懒汉式单例 单例模式：所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。 　　1、该类只能有一个实例化对象。 　　2、单例类必须自己创建唯一实例。 　　3、单例类必须给其他所有对象提供这同一实例对象。 1.1、饿汉式1： class Bank{ //1.私化类的构造器 private...
设计模式——单例模式（singleton）的六种写法
weixin_44943998的博客
12-11 137
单例模式（singleton） 饿汉式(推荐，满足大部分情况) public class Mgr01 { // 类加载时就实例化一个对象 private static final INSTANSCE = new Mgr01(); // 将构造方法私有化，他人就无法new出来一个新的对象 private Mgr01(){}; // 只能通过方法来获取对象 public static Mgr01 getInstance() { return INSTANSCE; }; } 类加载到内存后，就实例化
设计模式- Singleton单例模式的8种写法
模式情怀的专栏
04-21 742
设计模式、单例模式
设计模式 —— Singleton 模式
一步一步往上爬
05-31 2472
设计模式之单例模式介绍。几种单例模式浅析。
单例(Singleton)设计模式
jld2700zx的博客
09-25 673
单例(Singleton)设计模式 设计模式：解决某一类问题行之有效的解决办法 一、单例设计模式解决的问题### 可以保证一个类对象的唯一性场景：多个程序要使用一个配置文件中的数据，并且要实现数据共享和交换。那么，必须要将多个数据封装到一个对象中。多个程序同时操作同一个对象。二、实现过程怎样能保证对象的唯一性1.一个类要是提供了构造函数，就可能产生多个对象，所以不要让其他程序建立对象。2.仅仅在
如何用C++写一个Singleton 单例模式
小榕流光的专栏
11-01 1533
单例模式是比较常用的设计模式，尤其是在游戏设计中会经常用到，在面试中也是非常容易被问到和实现。今天我们来看看如何用C++来实现一个singleton。 单例模式的主要特性是只能实例化一个对象，在游戏中我们会有各种资源，我们也会在各个地方需要访问这些资源，那么如何得到这些资源呢？我们可以写一个资源管理类来获得各种你想要的资源，问题是在不同的类中如果你想获取游戏资源，就要新建一个资源管理类，这样其实
设计模式-Singleton模式
qq_23128065的博客
05-27 4855
Singleton模式是什么？ Singleton字面意思，单例，那也就是说无论如何这个类只有一个实例对象，你没有办法new出多个这个类的实例。 应用场景 想确保任何情况下都绝对只有1个实例 想在程序上表现出“只存在一个实例” 比如在写Javaweb程序时候，使用框架设置的一些全局配置。你要保证在任何地方调用这个配置都是一样的，是同一个，而不是各个地方调用的都是不一样的，那样的话，全局配置相当...
设计模式一：单例模式（Singleton Pattern）
songzi1228的博客
11-19 418
目录 相关视频： 相关文章： 相关面试题： 一、概述： 二、理解： 三、所有单例模式 （1）、饿汉式： 代码实例： 特点： 不足： （2）、懒汉式： （3）、双重校验锁DCL(double checked locking) （4）、静态内部类实现（最推荐） （5）、枚举单例 四、Android中的单例 相关视频： Java设计模式之单例模式视频课程 模式的秘密...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值