玩转单例模式

已于 2022-03-22 08:13:22 修改
阅读量265 收藏
点赞数 2
分类专栏： java基础 文章标签： java 设计模式 单例模式 枚举类 反射
于 2020-02-26 07:18:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43810802/article/details/104497679
版权

Singleton

单例模式，就是一个类只能有一个实例。

单例模式的关键在于构造器私有化，这样就不能在外面new。

Eager Mode

/**
 * eager mode of singleton
 * load the instance as soon as the class file is loaded by classloader
 */
public class EagerMode {

    private static EagerMode eagerMode = new EagerMode();

    private EagerMode(){}

    public static EagerMode getEagerMode(){
        return eagerMode;
    }

}

类被加载时，实例就会创建，这叫饿汉模式。

对于轻量级的对象，倒是可以这么做。

如果从头到尾都没有用到这个对象，那么又是一种对资源的浪费。

那么，我们就懒加载吧。

Lazy Mode

懒加载就是，你要实例的时候我才new出来，不是你要不要我都new。

package singletonPattern;

/**
 * simple version of lazy mode of singleton
 */
public class LazyMode {
    private static LazyMode lazyMode = null;

    private LazyMode(){

    }

    public static LazyMode getLazyMode(){
        if(lazyMode == null){
            lazyMode = new LazyMode();
        }

        return lazyMode;
    }
}

代码本身没有问题，但是它经不住多线程的压力。

我在getLazyMode里面打印一句话：

package singletonPattern;

/**
 * simple version of lazy mode of singleton
 */
public class LazyMode {
    private static LazyMode lazyMode = null;

    private LazyMode(){

    }

    public static LazyMode getLazyMode(){
        if(lazyMode == null){
            System.out.println("the instance is null");
            lazyMode = new LazyMode();
        }

        return lazyMode;
    }
}

多个线程的情况，如果是安全的话，那么打印只会执行一次：

为了加强效果，我让所有到达getLazyMode入口的线程都睡300毫秒：

package singletonPattern;

import java.util.concurrent.TimeUnit;

/**
 * simple version of lazy mode of singleton
 */
public class LazyMode {
    private static LazyMode lazyMode = null;

    private LazyMode(){

    }

    public static LazyMode getLazyMode(){
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(lazyMode == null){
            System.out.println("the instance is null");
            lazyMode = new LazyMode();
        }

        return lazyMode;
    }
}

测试方法：

@Test
    public void test02() {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{

                LazyMode.getLazyMode();
            }).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

结果：

the instance is null
the instance is null
the instance is null
the instance is null
the instance is null
the instance is null
the instance is null
the instance is null
the instance is null

每打印一句the instance is null，就会new一个对象，所以，单例模式就被破坏了。

解决的办法是：加锁。

Thread-safe Lazy Mode

package singletonPattern;

import java.util.concurrent.TimeUnit;

/**
 * simple version of lazy mode of singleton
 */
public class LazyMode {
    private static LazyMode lazyMode = null;

    private LazyMode(){

    }

    public synchronized static LazyMode getLazyMode(){
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(lazyMode == null){
            System.out.println("the instance is null");
            lazyMode = new LazyMode();
        }

        return lazyMode;
    }
}

这铁定是没有问题的，但是，100个线程先后在getLazyMode这里排队，太慢了。

问题的关键是，真正走进if(lazyMode == null)的只有一个线程，其他的直接return实例就行了。

因此我们可以用synchronize代码块：

package singletonPattern;

import java.util.concurrent.TimeUnit;

/**
 * simple version of lazy mode of singleton
 */
public class LazyMode {
    private static LazyMode lazyMode = null;

    private LazyMode(){

    }

    public static LazyMode getLazyMode(){
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(lazyMode == null){
            synchronized (LazyMode.class){
                System.out.println("create the instance!");
                lazyMode = new LazyMode();
            }
        }

        return lazyMode;
    }
}

如果lazyMode是null，那就去new，否则的话，你就直接return。

这比在方法上加synchronize效率高多了。

但是，如果有两个线程同时走到if(lazyMode == null)，同样会有线程安全问题。经过测试也测到了打印两句create the instance!的情况。

于是，我们还要加一层判断：

 public static LazyMode getLazyMode(){
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //to make the code efficient
        if(lazyMode == null){
            synchronized (LazyMode.class){
                //to make thread safe
                if(lazyMode == null){
                    System.out.println("create the instance!");
                    lazyMode = new LazyMode();
                }
            }
        }

        return lazyMode;
    }

这叫Double Check Lock，双重判空。

第一层判空，是为了让代码更有效、更快。

第二层判空，是为了线程安全。想象一下，如果有两个线程进了if(lazyMode == null)，其中一个线程先进synchronize块，使得lazyMode有值，这样第二个线程就进不了第二层的if(lazyMode == null)。

这似乎已经完美了，但还有一个问题，那就是new LazyMode()并非原子性的。

原子性，就是一个单一操作，new一个对象，有三个操作：

1.给LazyMode实例分配内存空间
2.执行LazyMode的构造方法
3.使变量lazyMode指向堆中的LazyMode对象。

因为JVM有指令重排，所以最后的顺序可能不是1-2-3，而是1-3-2。

假设线程A走了1-3，这时lazyMode已经不是null了，所以线程B会直接return，这就出错了。

虽然概率小，但是我们还是要想办法避免。

package singletonPattern;

import java.util.concurrent.TimeUnit;

/**
 * simple version of lazy mode of singleton
 */
public class LazyMode {
    private static volatile LazyMode lazyMode = null;

    private LazyMode(){

    }

    public static LazyMode getLazyMode(){
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //to make the code efficient
        if(lazyMode == null){
            synchronized (LazyMode.class){
                //to make thread safe
                if(lazyMode == null){
                    System.out.println("create the instance!");
                    //not atomic
                    lazyMode = new LazyMode();
                }
            }
        }

        return lazyMode;
    }
}

给lazyMode加上volatile修饰，就会防止指令重排，读操作一定后于写操作，所以线程B拿到的对象没有问题。

至此，线程安全的、懒加载的单例模式就成型了。

Static Inner Class

还有一种写法，就是静态内部类的写法：

package singletonPattern;

/**
 * we use static inner class to restore the instance
 * 
 */
public class Outer {
    private Outer(){

    }

    private static class Inner{
        private static final Outer INSTANCE = new Outer();
    }

    public static Outer getInstance(){
        return Inner.INSTANCE;
    }
}

这对比饿汉模式的好处是，它是懒加载的。

只有调用Inner.INSTANCE时，才会去new对象。关于这一点，debug一下就能看到。

同时，它又是线程安全的。JVM在类的初始化阶段会获取一个锁，这个锁将保证完成实例化的线程只有一个。

因此，这也是很棒的写法。

destroy everything by reflection

上面的东西好像很厉害，但是，反射技术击破一切。

拿eager mode开刀吧（其他都一样的）：

  @Test
    public void test04() throws Exception {
        Constructor<EagerMode> declaredConstructor = EagerMode.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        EagerMode instance1 = declaredConstructor.newInstance();
        EagerMode instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }

只要用declaredConstructor.setAccessible(true);，构造器的private就不起作用了。结果是：

singletonPattern.EagerMode@5b80350b
singletonPattern.EagerMode@5d6f64b1

两个实例。

不过我们可以在构造器上加异常来防止反射。

  private EagerMode(){
        if(eagerMode != null){
            throw new RuntimeException("Don't use reflection, stupid ass!");
        }
    }

但是，对于LazyMode，这一招并不管用，由于是懒加载，实例一开始确实是null，于是就不会抛出异常。

那么，怎么做才能对反射免疫呢？

Enum

我们看到，在newInstance方法里：

  @CallerSensitive
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

如果构造器存在于枚举类的话，直接报错。

我们试一下：

枚举类的单例模式：

package singletonPattern;

public enum Singleton {
    INSTANCE;
}

搞它：

 @Test
    public void test06() throws Exception{
        Constructor<Singleton> declaredConstructor = Singleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Singleton singleton = declaredConstructor.newInstance();
        System.out.println(singleton);

    }

报的错是：

java.lang.NoSuchMethodException: singletonPattern.Singleton.<init>()

是构造方法调的不对。

我们最好能看到枚举类反编译的结果：

使用jad反编译Singleton.class:

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Singleton.java

package singletonPattern;


public final class Singleton extends Enum
{

    public static Singleton[] values()
    {
        return (Singleton[])$VALUES.clone();
    }

    public static Singleton valueOf(String name)
    {
        return (Singleton)Enum.valueOf(singletonPattern/Singleton, name);
    }

    private Singleton(String s, int i)
    {
        super(s, i);
    }

    public static final Singleton INSTANCE;
    private static final Singleton $VALUES[];

    static 
    {
        INSTANCE = new Singleton("INSTANCE", 0);
        $VALUES = (new Singleton[] {
            INSTANCE
        });
    }
}

构造器里面还需要两个参数：

    @Test
    public void test06() throws Exception{
        Constructor<Singleton> declaredConstructor = Singleton.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        Singleton singleton = declaredConstructor.newInstance();
        System.out.println(singleton);

    }

这时候报的错就是我们预料的了：

java.lang.IllegalArgumentException: Cannot reflectively create enum objects

至于为什么需要两个参数，因为每个枚举类都继承了Enum：

protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

使用super调用了父类构造器。

单例模式最终使用枚举类的方式最强悍！

spark man
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java SE程序 单例模式
01-21
Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式...
复习一下c#中的override和new和他们在内存中的事
CsdnLlgl的博客
07-15 299
c#中的override和new
C++设计模式总结
长期更新Java自学笔记
09-06 4214
一、单例模式 一个类不管常见多少次对象，永远只能得到该类型一个对象的实例 // p1、p2、p3指向同一对象 A* p1 = new A(); A* p2 = new A(); A* p3 = new A(); 饿汉式单例模式： 还没有获取实例对象，实例对象就已经产生了 优点：线程安全。对象存放在数据段，main函数还没有开始执行，对象就已经初始化好了，一定是线程安全的。 缺点： 获取在软件启动的时候，并没有使用到这个对象，然而这个对象已经产生，这就比较浪费资源。 #include<iostream
设计模式之单例模式
二木成林
03-04 685
单例模式 概念 所谓类的单例设计模式（Singleton），就是保证一个类仅有一个实例，并提供一个访问我它的全局访问点。 不允许去new它，只能通过一个（静态）方法来获取它的对象实例，如果某类没有定义构造器方法，那么会默认提供一个构造器方法，如果已有则不会，所以也需要将构造器方法用private进行修饰，不允许new该对象。 单例模式有如下8种实现方式： 饿汉式(静态常量) 饿汉式（静态代码块） 懒汉式(线程不安全) 懒汉式(线程安全，同步方法) 懒汉式(线程安全，同步代码块) 双重
单例模式的优点和缺点(摘自)
CyRo
11-04 7116
1.主要优点         单例模式的主要优点如下：         (1) 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。       (2) 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。       (3) 允许可变数目的实例。基于单例模式我们可以进
C++ 单例模式
zgcjaxj的博客
04-01 178
单例就是一个类在全局只被例化一次。单例可以减少不必要的new/delete过程，提高performance。单例的实现方法参考 https://www.cnblogs.com/sunchaothu/p/10389842.html 其中，构造函数设置为private，也就是不能从外部来new 一个对象，只能通过类内的get_instance函数来new。 =delete 阻止拷贝 和 赋值运算符。 =delete,用于定义删除函数，在旧标准下，我们如果希望阻止拷贝可以通过显式声明拷贝 =defaul.
基于JavaScript实现单例模式
01-19
首先，了解一下什么是单例模式，这里我直接把软件开发网中的定义给copy过来： 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。...
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
最新发布
08-03
2020-02-10 王争设计模式之美进入课程讲述：冯永吉时长 10:21大小 8.31M上两节课中，我们针对单例模式，讲解了单例的应用场景、几种常见的代码实现
C#设计模式–单例模式
12-22
　说到单例模式，大家第一反应应该是——什么是单例模式？，从“单例”字面意思上理解为——一个类只有一个实例，所以单例模式也是保证一个类只有一个实例的一种实现方法罢了(设计模式其实是帮助我们解决实际开发...
Java 单例模式实现
01-20
饿汉式 线程安全，调用效率高，但是不能延时加载。 public class Singleton { private static Singleton instance = new ...如果方法没有 synchronized，单例没有 volatile , 则线程不安全。 public class Singleton {
单例模式
ChuJiangKeDeJiuShu的专栏
01-27 343
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例
__new__()方法、单例模式
微信公众号进阶的阿牛哥的博客
04-05 381
一、_ _ new_ _()方法 class A(object): def __init__(self): print('我是init方法') print('我是测试') a=A() 结果： （因为是先加载类，之后再加载实例） 1、对象创建时执行顺序： （1）通过__new__()方法创建对象 （2）并将对象返回，传给__init__() 例如： 以下代码打印输出的顺序？ A.init,new B.init C.new D.__new,init class Demo(object):
定义一个单例模式的类，在这个类中，只有唯一的实例，不能new出来其他的实例对象。
diandian82的专栏
06-15 3334
using System; namespace MySingleton{        class Class1        {                [STAThread]                static void Main(string[] args)                {                        Si
Python | 单例模式、new方法
hhhxykeke的博客
12-21 759
一、单例设计模式 1、设计模式 设计模式是前人工作的总结和提炼，通常，被人们广泛流传的设计模式都是针对 某一特定问题的成熟的解决方案 使用 设计模式 是为了可重用代码，让代码更容易被让人理解，保证代码可靠性 2、单例设计模式 目的——让 类 创建的对象，在系统中只有唯一的一个实例 每一次执行 类名( ) 返回的对象，内存地址是相同的，如音乐播放器 同时只能播放一首歌。 二、__new__方法 使用类名() 创建对象时，...
面向对象补充-init和new方法及单例模式
qq_42052864的博客
08-02 156
代码】面向对象补充-init和new方法及单例模式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值