单例模式（万字长文精讲）

• @Author: Liziba

• @Date: 2021/6/27 15:49

*/

public class HungrySingletonDemo2 {

private static final HungrySingletonDemo2 HUNGRY_SINGLETON_DEMO_2;

static {

HUNGRY_SINGLETON_DEMO_2 = new HungrySingletonDemo2();

}

public static HungrySingletonDemo2 getInstance() {

return HUNGRY_SINGLETON_DEMO_2;

}

}

饿汉式单例可以保证线程安全，执行效率高，同时编码简单容易理解。但是饿汉式单例只适用于单例对象减少的情况，如果大量编写饿汉式单例不仅会给系统启动带来负担，也可能会导致内存的浪费，比如创建的单例对象在程序运行过程中并未使用。因此这对内存浪费这个问题，我们衍生出了懒汉式单例。

​

5、懒汉式单例

懒汉式单例主要体现在一个懒字，也就是说类加载的时候我懒得实例化，等你需要用了再说吧！接下来的懒汉式单例中我通过一步步的优化和推翻来演进如何编写一个优秀的单例。

5.1 普通懒汉式单例

package com.lizba.pattern.singleton.lazy;

/**

•    简单懒汉式单例示例代码1
  

• @Author: Liziba

• @Date: 2021/6/27 16:01

*/

public class LazySingletonDemo1 {

private static LazySingletonDemo1 LAZY_SINGLETON = null;

private LazySingletonDemo1() {

}

public static LazySingletonDemo1 getInstance() {

if (LAZY_SINGLETON == null) {

LAZY_SINGLETON = new LazySingletonDemo1();

}

return LAZY_SINGLETON;

}

}

这是一个非常普通的懒汉式单例模式的写法，相信很多初学者会编码成这样，但其实这是一种错误的线程不安全的写法。我们通过一个断点测试来证明其不安全，我采用的是IDEA编写代码，通过设置断点为Thread模式来使得线程1和线程2同时满足LAZY_SINGLETON == null。

​

测试代码

package com.lizba.pattern.singleton.lazy;

/**

•  测试懒汉式单例1的线程不安全
  

• @Author: Liziba

• @Date: 2021/6/27 16:05

*/

public class LazySingletonTest {

public static void main(String[] args) {

new Thread(() -> run(), “Thread-1”).start();

new Thread(() -> run(), “Thread-2”).start();

System.out.println(“End of test…”);

}

public static void run() {

LazySingletonDemo1 lad = LazySingletonDemo1.getInstance();

System.out.println(Thread.currentThread().getName() + " : " + lad);

}

}

断点设置如下图，邮件打在LAZY_SINGLETON == null的断点上，选择Suspend为Thread，然后点击Done即可。

调试过程，我们执行测试代码，使其两个线程均执行到LAZY_SINGLETON == null，然后F8使得线程1进入if语句；切换至线程2F8进入if语句，此时我们的目的便达到了（在实际的并发使用场景中，这种情况是非常可能出现的）

此时线程1和线程2中的对象并不是同一个对象，所以这种单例编码方式是不正确的。

5.2 同步懒汉式单例

关于上述的单例模式编码，部分读者会想到通过同步原语synchronized加在getInstance()方法上来解决，此时代码如下所示：

package com.lizba.pattern.singleton.lazy;

/**

•  synchronized修饰方法getInstance()的懒汉式单例
  

• @Author: Liziba

• @Date: 2021/6/27 16:37

*/

public class LazySingletonDemo2 {

private static LazySingletonDemo2 LAZY_SINGLETON = null;

private LazySingletonDemo2() {

}

// synchronized修饰getInstance()方法

public static synchronized LazySingletonDemo2 getInstance() {

if (LAZY_SINGLETON == null) {

LAZY_SINGLETON = new LazySingletonDemo2();

}

return LAZY_SINGLETON;

}

}

如上通过给getInstance()加上synchronized关键字，使得同步方法中的代码块线程安全了，但是随之而来的是在大量并发调用该方法的性能问题，大量的线程会阻塞在这个方法上，所以有些我们通过缩小锁锁住的范围来尽可能的提升其并发性能。代码衍生为如下所示：

package com.lizba.pattern.singleton.lazy;

/**

•    synchronized修饰方法代码块
  

• @Author: Liziba

• @Date: 2021/6/27 16:53

*/

public class LazySingletonDemo3 {

private static LazySingletonDemo3 LAZY_SINGLETON = null;

private LazySingletonDemo3() {

}

public static LazySingletonDemo3 getInstance() {

synchronized (LazySingletonDemo3.class) {

if (LAZY_SINGLETON == null) {

LAZY_SINGLETON = new LazySingletonDemo3();

}

return LAZY_SINGLETON;

}

}

}

如上这种锁住代码块的方式，虽然缩小了锁同步的范围，但是并未本质上的改变每个线程均需要阻塞这个问题，因此我们可以前置if(LAZY_SINGLETON == null)这个判断，使得部分线程判断对象被实例化后无需加锁，直接返回即可，其代码如下所示：

package com.lizba.pattern.singleton.lazy;

/**

•  if(LAZY_SINGLETON == null)前置于同步代码块，单例模式示例4
  

• @Author: Liziba

• @Date: 2021/6/27 16:56

*/

public class LazySingletonDemo4 {

private static LazySingletonDemo4 LAZY_SINGLETON = null;

private LazySingletonDemo4() {

}

public static LazySingletonDemo4 getInstance() {

// 前置if判断

if (LAZY_SINGLETON == null) {

synchronized (LazySingletonDemo4.class) {

LAZY_SINGLETON = new LazySingletonDemo4();

}

}

return LAZY_SINGLETON;

}

}

如上代码看似兼顾了性能和同步对象的实例化，但是这里的同步语言并不能保证对象只实例化一次，它只能保证每次只有一个线程在实例化这个对象。试想一下，如果线程1和线程2均执行到代码21行，此时线程1获得锁继续执行，实例化对象LazySingletonDemo4，当线程1退出锁后，线程2获取到锁，线程2也会对LazySingletonDemo4进行实例化，这种情况也可以用上面的断点法测试出来。所以这种情况是错误的，但是只有小小的改动一下即可，改动后的方式如下所示。

​

5.3 双重检查锁懒汉式单例

双重检查锁看名字高大上，其实就是在上面的LazySingletonDemo4多个if判断而已，理解为双重检查+锁可能更明了，其代码如下所示：

package com.lizba.pattern.singleton.lazy;

/**

•  双重检查锁
  

• @Author: Liziba

• @Date: 2021/6/27 17:04

*/

public class LazySingletonDemo5 {

private static LazySingletonDemo5 LAZY_SINGLETON = null;

private LazySingletonDemo5() {

}

public static LazySingletonDemo5 getInstance() {

// 检查1

if (LAZY_SINGLETON == null) {

synchronized (LazySingletonDemo5.class) {

// 检查2（这就是双重检查）

if (LAZY_SINGLETON == null) {

LAZY_SINGLETON = new LazySingletonDemo5();

}

}

}

return LAZY_SINGLETON;

}

}

双重检查锁看似完全正确，其实还存在一个指令重排序问题，至于什么是指令重排序，在我的并发编程专题中有详细的讲述，这里不再细讲；简单来说，就是编译器和处理器会针对编译后的指令进行重新排序，这种重排序对应编译器和处理器来说是会带来一定的性能提升的，但是对于编写代码的程序员来说，如果不正确的使用同步语义，将会导致非预期结果出现。在上述示例中第24行代码LAZY_SINGLETON = new LazySingletonDemo5()，在编译器编译后生成的字节码会有三条指令如下所示：

memory = allocate();　　// 1：分配对象的内存空间

ctorInstance(memory);　// 2：初始化对象

instance = memory;　　// 3：设置instance指向刚分配的内存地址

这三条指令中，指令2和指令3可能会出现重排序，也就是说对象的初始化会被后置到将分配的地址指向对象的引用这个指令的后面；这种重排序，假设是在线程1执行中发生了，此时线程2执行到第20行 if (LAZY_SINGLETON == null)，此时LAZY_SINGLETON 并不为null，程序会直接返回LAZY_SINGLETON对象，但是此时的对象是一个实例化不完全的对象，这种情况是不允许存在的。

其解决办法是通过volatile关键字借助其内存语义来禁止指令重排序，这样2和3指令之间的重排序将会被禁止，这涉及到JMM规范，需要的请查看我的并发专题系列文章。其改造代码如下所示：

package com.lizba.pattern.singleton.lazy;

/**

•  volatile修饰 LAZY_SINGLETON禁止指令重排序
  

• @Author: Liziba

• @Date: 2021/6/27 17:12

*/

public class LazySingletonDemo6 {

// volatile修饰LAZY_SINGLETON反正指令重排序

private static volatile LazySingletonDemo6 LAZY_SINGLETON = null;

private LazySingletonDemo6() {

}

public static LazySingletonDemo6 getInstance() {

// 检查1

if (LAZY_SINGLETON == null) {

synchronized (LazySingletonDemo6.class) {

// 检查2（这就是双重检查）

if (LAZY_SINGLETON == null) {

LAZY_SINGLETON = new LazySingletonDemo6();

}

}

}

return LAZY_SINGLETON;

}

}

上述演进过程，其实已经编写一个比较完整的懒汉式单例的示例代码，但是介于语言的一些特性，也就是反射这个无事不为的操作，能破坏这种场景。我们先来看看怎么破坏的，其破坏示例代码如下：

package com.lizba.pattern.singleton.lazy;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

/**

•  破坏双重检查锁单例
  

• @Author: Liziba

• @Date: 2021/6/27 17:34

*/

public class DoubleCheckTest {

public static void main(String[] args) {

Class singletonClass = LazySingletonDemo6.class;

try {

Constructor c = singletonClass.getDeclaredConstructor(null);

// 破坏private访问权限

c.setAccessible(true);

LazySingletonDemo6 lsd1 = c.newInstance();

LazySingletonDemo6 lsd2 = c.newInstance();

System.out.println(lsd1 == lsd2);

} catch (Exception e) {

e.printStackTrace();

}

}

}

输出结果：false

处理方式十分简单粗暴，就是在构造方法中抛出异常，抛出异常这种解决方式，在很多不合法的场景中非常常见，修改后的代码如下:

package com.lizba.pattern.singleton.lazy;

/**

•  防止反射破坏单例
  

• @Author: Liziba

• @Date: 2021/6/27 17:56

*/

public class LazySingletonDemo7 {

private static volatile LazySingletonDemo7 LAZY_SINGLETON = null;

// 在构造函数中判断如果LAZY_SINGLETON不为空，则抛出异常即可

private LazySingletonDemo7() {

if (LAZY_SINGLETON != null) {

throw new RuntimeException(“This operation is forbidden.”);

}

}

public static LazySingletonDemo7 getInstance() {

// 检查1

if (LAZY_SINGLETON == null) {

synchronized (LazySingletonDemo7.class) {

// 检查2（这就是双重检查）

if (LAZY_SINGLETON == null) {

LAZY_SINGLETON = new LazySingletonDemo7();

}

}

}

return LAZY_SINGLETON;

}

}

5.4 静态内部类懒汉式单例

在双重检查锁的演进中，我们通过不断的缩小锁的范围，以及对对象是否未实例化做了两次判断，最后对反射获取对象这种操作做了处理；但是归根到底，双重检查锁中有个锁字，就难规避性能讨论的问题，其实这种问题在大部分场景中是可以接受；如果硬要寻求一种既是懒汉式，又不需要锁的单例模式，那么通过静态内部类的加载特性，巧妙的实现懒汉式单例模式会是一种不错的选择。

Java语言中的内部类是延时加载的，只有在第一次使用的时候才会被加载，不使用则不加载。

我们通过该特性，编码的懒汉式单例如下所示：

package com.lizba.pattern.singleton.lazy;

/**

•  内部类懒汉式单例
  

• @Author: Liziba

• @Date: 2021/6/27 20:14

*/

public class LazySingletonDemo8 {

private LazySingletonDemo8() {

if (LazyHolderInner.LAZY_SINGLETON != null) {

throw new RuntimeException(“This operation is forbidden.”);

}

}

public static LazySingletonDemo8 getInstance() {

return LazyHolderInner.LAZY_SINGLETON;

}

/**

• 使用内部类，被使用才加载的特性来

*/

private static class LazyHolderInner {

public static final LazySingletonDemo8 LAZY_SINGLETON = new LazySingletonDemo8();

}

}

6、单例模式的最佳方式

Joshua Bloch大师的Effective Java第二版中说枚举式单例是实现单例的最佳方式，那我们就来看看枚举式单例的实现吧。编码如下：

package com.lizba.pattern.singleton.hungry;

/**

• 枚举式单例示例

• @Author: Liziba

• @Date: 2021/6/27 20:29

*/

public enum EnumSingletonDemo {

SINGLETON_INSTANCE;

private Object object;

public Object getObject() {

return object;

}

public void setObject(Object object) {

this.object = object;

}

public static EnumSingletonDemo getInstance() {

return SINGLETON_INSTANCE;

}

}

测试枚举式单例：

package com.lizba.pattern.singleton.hungry;

/**

•  枚举式单例测试
  

• @Author: Liziba

• @Date: 2021/6/27 20:33

*/

public class EnumSingletonTest {

public static void main(String[] args) {

EnumSingletonDemo instance1 = EnumSingletonDemo.getInstance();

instance1.setObject(new Integer(100));

EnumSingletonDemo instance2 = EnumSingletonDemo.getInstance();

Integer value = (Integer) instance2.getObject();

System.out.println(instance1 == instance2);

System.out.println(value);

}

}

查看输出结果：

更加上述输出结果，可以非常明确的发现，instance1和instance2就是同一个对象，那么为何枚举可以实现单例呢？为何其被Joshua Bloch大师称为最好的单例模式编码方式呢？

​我们通过反编译工具jad来一探究竟，首先使用jad，在EnumSingletonDemo.class所在的目录下执行jad EnumSingletonDemo.class，这样会生成一个EnumSingletonDemo.jad文件；

生成的EnumSingletonDemo.jad文件内容如下：我们看到代码的最后有一个静态代码块，在这里一看便知。

// 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: EnumSingletonDemo.java

package com.lizba.pattern.singleton.hungry;

public final class EnumSingletonDemo extends Enum{

public static EnumSingletonDemo[] values(){

return (EnumSingletonDemo[])$VALUES.clone();

}

public static EnumSingletonDemo valueOf(String name){

return (EnumSingletonDemo)Enum.valueOf(com/lizba/pattern/singleton/hungry/EnumSingletonDemo, name);

}

private EnumSingletonDemo(String s, int i) {

super(s, i);

}

public Object getObject() {

return object;

}

public void setObject(Object object){

this.object = object;

}

public static EnumSingletonDemo getInstance() {

return SINGLETON_INSTANCE;

}

public static final EnumSingletonDemo SINGLETON_INSTANCE;

private Object object;

private static final EnumSingletonDemo $VALUES[];

// 静态代码块中实例化了EnumSingletonDemo

static {

SINGLETON_INSTANCE = new EnumSingletonDemo(“SINGLETON_INSTANCE”, 0);

$VALUES = (new EnumSingletonDemo[] {

SINGLETON_INSTANCE

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

Android开发除了flutter还有什么是必须掌握的吗？

相信大多数从事Android开发的朋友们越来越发现，找工作越来越难了，面试的要求越来越高了

除了基础扎实的java知识，数据结构算法，设计模式还要求会底层源码，NDK技术，性能调优，还有会些小程序和跨平台，比如说flutter，以思维脑图的方式展示在下图；

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

{

SINGLETON_INSTANCE

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-diPG5Shy-1713528752851)]

[外链图片转存中…(img-YwmtKLqQ-1713528752852)]

[外链图片转存中…(img-HtzHrt2E-1713528752853)]

[外链图片转存中…(img-XCtds1gT-1713528752854)]

[外链图片转存中…(img-KfwpkFui-1713528752855)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

Android开发除了flutter还有什么是必须掌握的吗？

相信大多数从事Android开发的朋友们越来越发现，找工作越来越难了，面试的要求越来越高了

除了基础扎实的java知识，数据结构算法，设计模式还要求会底层源码，NDK技术，性能调优，还有会些小程序和跨平台，比如说flutter，以思维脑图的方式展示在下图；

[外链图片转存中…(img-QiyaylbV-1713528752856)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！