你应该了解的单例模式

单元素的枚举类型经常成为实现 Singleton 的最佳方法 。

什么是单例？就一条基本原则，单例对象的类只会被初始化一次。在 Java 中，我们可以说在 JVM 中只存在该类的唯一一个对象实例。在 Android 中，我们可以说在程序运行期间，该类有且仅有一个对象实例。

单例模式的简单实现步骤：

  1. 构造方法私有，保证无法从外部通过 new 的方式创建对象。
  2. 对外提供获取该类实例的静态方法。
  3. 类的内部创建该类的对象，通过第 2 步的静态方法返回。

按照上述步骤写下你认为比较严谨的单例模式，然后看看你所写下的单例能否满足以下条件：

  • 你的单例按需加载吗？
  • 你的单例线程安全吗?涉及到并发三要素：原子性、可见性、有序性
  • 你的单例暴力反射和序列化安全吗？

如果你的单例已满足上述条件，给自己鼓个掌，如不满足上述条件或者有兴趣的可接着了解下，主要从下面几种创建单例的方式描述对应实现方式的优缺点以及如何优化：

  • 饿汉模式
  • 懒汉模式
    • 延迟加载
    • 静态内部类
    • 双重检锁（DCL）
  • 枚举实现单例

一、饿汉式

public class SingleTon {
    //第三步创建唯一实例
    private static SingleTon instance = new SingleTon();
    
    //第一步构造方法私有
    private SingleTon() {
    }
    
    //第二步暴露静态方法返回唯一实例
    public static SingleTon getInstance() {
        return instance;
    } 
}

优点：
设计简单 ，解决了多线程实例化的问题。

缺点：
在虚拟机加载SingleTon类的时候，将会在初始化阶段为类静态变量赋值，也就是在虚拟机加载该类的时候（此时可能并没有调用 getInstance 方法）就已经调用了 new SingleTon(); 创建了该对象的实例，之后不管这个实例对象用不用，都会占据内存空间。

二 、懒汉式

public class SingleTon {
    //创建唯一实例
    private static SingleTon instance = null;
    
    private SingleTon() {
    }
    
    public static SingleTon getInstance() {
        //延迟初始化 在第一次调用 getInstance 的时候创建对象
        if (instance == null) {
            instance = new SingleTon();
        }
        return instance;
    } 
}

优点：
设计也是比较简单的，和饿汉式不同，当这个Singleton被加载的时候，被static修饰的静态变量将会被初始化为null，这个时候并不会占用内存，而是当第一次调用getInstance方法的时候才会被初始化实例对象，按需创建。

缺点：
在单线程环境下是没有问题的，在多线程环境下，会产生线程安全问题。在有两个线程同时 运行到了 instane == null这个语句，并且都通过了，那他们就会都各自实例化一个对象，这样就又不是单例了。

如何解决懒汉式在多线程环境下的多实例问题？

  • 静态内部类

    public class SingleTon {
    
    private static class InnerStaticClass{
        private static SingleTon singleTon  = new SingleTon();
    }

    public SingleTon getInstance(){
        return InnerStaticClass.singleTon;
    }
    
    private SingleTon() {
    }
}

  • 直接同步方法

    public class SingleTon {
    //创建唯一实例
    private static SingleTon instance = null;
    
    private SingleTon() {
    }
    
    public static synchronized SingleTon getInstance() {
        if (instance == null) {
            instance = new SingleTon();
        }
        return instance;
    } 
}

    优点：
    加锁只有一个线程能实例该对象，解决了线程安全问题。

    缺点：
    对于静态方法而言，synchronized关键字会锁住整个 Class，每次调用getInstance方法都会线程同步，效率十分低下，而且当创建好实例对象之后，也就不必继续进行同步了。

    备注：此处的synchronized保证了操作的原子性和内存可见性。

  • 同步代码块（双重检锁方式DCL）

    public class SingleTon {
    //创建唯一实例
    private static volatile SingleTon instance = null;
    
    private SingleTon() {
    }
    
    public static SingleTon getInstance() {
        if (instance == null) {
            synchronized (SingleTon.class) {   
                if (instance == null) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    } 
}

    优点：
    添加了一个同步代码块，在同步代码块中去判断实例对象是否存在，如果不存在则去创建，这个时候其实就完全可以解决问题了，因为虽然是多个线程去获取实例对象，但是在同一个时间也只会有一个线程会进入到同步代码块，那么这个时候创建好对象之后，其他线程即便再次进入同步代码块，由于已经创建好了实例对象，便直接返回即可。但是为什么还要在同步代码块的上一步再次去判断instance为空呢？这个是由于当我们创建好实例对象之后，直接去判断此实例对象是否为空，如果不为空，则直接返回就好了，就避免再次进去同步代码块了，提高了性能。

    缺点：
    无法避免暴力反射创建对象。

    备注：此处的volatile发挥了内存可见性及防止指令重排序作用。

三、枚举实现单例

public enum SingletonEnum {
    INSTANCE;

    public static void main(String[] args) {
        System.out.println(SingletonEnum.INSTANCE == SingletonEnum.INSTANCE);
    }
}

枚举实现单例是最为推荐的一种方法，因为就算通过序列化，反射等也没办法破坏单例性。(关于Android使用枚举会产生性能问题的说法，这应该是Android 2.x系统之前内存紧张的时代了，现在已经Android Q了，相信某些场合枚举所带来的便利远远大于这点所谓的性能影响)

四. 如何避免单例模式反射攻击

以最初的DCL为测试案例，看看如何进行反射攻击及又如何在一定程度上避免反射攻击。
反射攻击代码如下：

 public static void main(String[] args) {

     SingleTon singleton1 = SingleTon.getInstance();
     SingleTon singleton2 = null;

     try {
         Class<SingleTon> clazz = SingleTon.class;
         Constructor<SingleTon> constructor = clazz.getDeclaredConstructor();
         constructor.setAccessible(true);
         singleton2 = constructor.newInstance();
     } catch (Exception e) {
         e.printStackTrace();
     }

     System.out.println("singleton1.hashCode():" + singleton1.hashCode());
     System.out.println("singleton2.hashCode():" + singleton2.hashCode());
 }

执行结果：

 singleton1.hashCode():1296064247
 singleton2.hashCode():1637070917

通过执行结果发现通过反射破坏了单例。
如何保证反射安全呢？只能以暴制暴，当已经存在实例的时候再去调用构造函数直接抛出异常，对构造函数做如下修改：

  public class SingleTon {
     //创建唯一实例
     private static volatile SingleTon instance = null;
   
     private SingleTon() {
         if (instance != null) {
             throw new RuntimeException("单例构造器禁止反射调用");
         }
     }
   
     public static SingleTon getInstance() {
         if (instance == null) {
           synchronized (SingleTon.class) {   
               if (instance == null) {
                   instance = new SingleTon();
               }
           }
       }
       return instance;
     } 
 }

此时可防御反射攻击,抛出异常如下：

 java.lang.reflect.InvocationTargetException
 at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
 at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
 at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
 at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
 at com.liujc.demo.TestUtil.testSingleInstance(TestUtil.java:45)
 at com.liujc.demo.TestUtil.main(TestUtil.java:33)
 Caused by: java.lang.RuntimeException: 单例构造器禁止反射调用
 at com.liujc.demo.SingleTon.<init>(SingleTon.java:16)
 ... 6 more
 Exception in thread "main" java.lang.NullPointerException
 at com.liujc.demo.TestUtil.testSingleInstance(TestUtil.java:49)
 at com.liujc.demo.TestUtil.main(TestUtil.java:33) 
 Process finished with exit code 1

然后我们把上述测试代码修改如下（调换了singleton1的初始化顺序）：

 public static void main(String[] args) {
     SingleTon singleton2 = null;

     try {
         Class<SingleTon> clazz = SingleTon.class;
         Constructor<SingleTon> constructor = clazz.getDeclaredConstructor();
         constructor.setAccessible(true);
         singleton2 = constructor.newInstance();
     } catch (Exception e) {
         e.printStackTrace();
     }

     System.out.println("singleton2.hashCode():" + singleton2.hashCode());

     SingleTon singleton1 = SingleTon.getInstance(); //调换了位置，在反射之后执行
     System.out.println("singleton1.hashCode():" + singleton1.hashCode());
 }

执行结果：

 singleton2.hashCode():1296064247
 singleton1.hashCode():1637070917

发现此防御未起到作用。

缺点：

  • 如果反射攻击发生在正常调用getInstance之前，每次反射攻击都可以获取单例类的一个实例，因为即使私有构造器中使用了静态成员（instance） ，但单例对象并没有在类的初始化阶段被实例化，所以防御代码不生效，从而可以通过构造器的反射调用创建单例类的多个实例；
  • 如果反射攻击发生在正常调用之后，防御代码是可以生效的；

如何避免序列化攻击？
只需要修改反序列化的逻辑就可以了，即重写 readResolve() 方法，使其返回统一实例。

   protected Object readResolve() {
       return getInstance();
   }

脆弱不堪的单例模式经过重重考验，进化成了完全体，延迟加载，线程安全，反射及序列化安全。简易代码如下：

  • 饿汉模式

    public class SingleTon {
    private static SingleTon instance = new SingleTon();
    
    private SingleTon() {
        if (instance != null) {
              throw new RuntimeException("单例构造器禁止反射调用");
         }
    }
    public static SingleTon getInstance() {
        return instance;
    } 
}

  • 静态内部类

    public class SingleTon {
    
    private static class InnerStaticClass{
        private static SingleTon singleTon  = new SingleTon();
    }

    public SingleTon getInstance(){
        return InnerStaticClass.singleTon;
    }
    
    private SingleTon() {
       if (InnerStaticClass.singleTon != null) {
              throw new RuntimeException("单例构造器禁止反射调用");
       }
    }
}

  • 懒汉模式

    public class SingleTon {
    //创建唯一实例
    private static SingleTon instance = null;
    
    private SingleTon() {
            if (instance != null) {
              throw new RuntimeException("单例构造器禁止反射调用");
         }
    }
    
    public static SingleTon getInstance() {
        //延迟初始化 在第一次调用 getInstance 的时候创建对象
        if (instance == null) {
            instance = new SingleTon();
        }
        return instance;
    } 
}

    缺点：

    • 如果反射攻击发生在正常调用getInstance之前，每次反射攻击都可以获取单例类的一个实例，因为即使私有构造器中使用了静态成员（instance） ，但单例对象并没有在类的初始化阶段被实例化，所以防御代码不生效，从而可以通过构造器的反射调用创建单例类的多个实例；
    • 如果反射攻击发生在正常调用之后，防御代码是可以生效的。

（枚举实现单例是最为推荐的一种方法，因为就算通过序列化，反射等也没办法破坏单例性,底层实现比如newInstance方法内部判断枚举抛异常）

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 228,156评论 6赞 531
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 98,401评论 3赞 415
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 176,069评论 0赞 373
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 62,873评论 1赞 309
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 71,635评论 6赞 408
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 55,128评论 1赞 323
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 43,203评论 3赞 441
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 42,365评论 0赞 288
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 48,881评论 1赞 334
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 40,733评论 3赞 354
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 42,935评论 1赞 369
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 38,475评论 5赞 358
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 44,172评论 3赞 347
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 34,582评论 0赞 26
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 35,821评论 1赞 282
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 51,595评论 3赞 390
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 47,908评论 2赞 372

推荐阅读更多精彩内容

  • 单例模式的八种写法比较
    单例模式是最常用到的设计模式之一，熟悉设计模式的朋友对单例模式都不会陌生。一般介绍单例模式的书籍都会提到 饿汉式 ...
    03ca2835cf70阅读 84评论 0赞 0
  • 设计模式之一：单例模式
    摘要：设计模式之一：单例模式目录介绍1.单例模式介绍2.单例模式定义3.单例模式使用场景4.单例模式的实现方式 4...
    肆虐的悲傷阅读 468评论 0赞 2
  • 实现单例模式的八种方法
    简介 单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。许多时候整个系统只需要拥有一个的...
    上杉丶零阅读 579评论 0赞 1
  • Java单例模式
    1. 实现单例模式 饿汉模式和懒汉模式单例模式根据实例化时机分为饿汉模式和懒汉模式。饿汉模式，是指不等到单例真正使...
    aaron1993阅读 225评论 0赞 0
  • 总结单例模式的几种实现方式及优缺点
    一、单例模式的定义 确保这个类在内存中只会存在一个对象,而且自行实例化并向整个应用系统提供这个实例。 二、单例模式...
    安仔夏天勤奋阅读 15,301评论 0赞 6