java彻底搞懂单例模式

彻底搞懂单例模式

前情提要：

• 饿汉式、懒汉式、静态内部类？蜻蜓点水
• volatitle关键字禁止指令重排之JMM内存模型？重在理解看不见
• 反射破坏单例？
• 枚举实现单例，反射无法破坏？

什么是单例模式：

百度百科：是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

应用场景：

1. 操作系统的任务管理器，因为同一台电脑无法同时打开两个任务管理器界面。
2. 程序的日志系统，因为如果同时有两个程序维护日志文件，日志内容无法追加。
3. web应用中配置文件的读取，因为配置文件是共享资源，非单例会创建多个相同的资源对象浪费系统内存、CPU等的性能。
4. 垃圾回收机制。
5. 线程池和连接池的实现。

以上可以看出，单例模式的应用场景：
共享资源的访问使用单例，如配置信息、日志信息等，避免建立多个相同的对象浪费系统资源
控制资源的访问使用单例，如线程池、连接池等，方便对于访问的资源进行控制。
1
2
3

实现套路：

1. 构造方法私有化
2. 提供一个静态方法获取对象实例

饿汉式-可用

1. 优点：简单方便，避免多线程问题
2. 缺点：类加载的时候完成初始化，如果未使用会在成内存浪费

//饿汉式，容易造成内存浪费
class HungrySingle{
    //模拟内存浪费
    private static Byte[] a = new Byte[1024*1000];
    private HungrySingle(){
        System.out.println(Thread.currentThread().getName());
    }
    //默认直接初始化对象实例
    private static final HungrySingle instance = new HungrySingle();
    public static HungrySingle getInstance(){
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

测试：启动30个线程，构造方法只会执行一次。为避免内存浪费可以再实际调用的时候再初始化实例对象，因此下面的懒汉式应运而生。

静态内部类

//静态内部类
class StaticInnerClassSingle{
    private StaticInnerClassSingle(){}

    private static class StaticInnerClassSingleInstance {
        private static StaticInnerClassSingle singleton = new StaticInnerClassSingle();
    }

    public static StaticInnerClassSingle getInstance(){
        return StaticInnerClassSingleInstance.singleton;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

懒汉式-不可用

1. 优点：无
2. 缺点：只能在单线程下使用

//懒汉式，线程不安全
class LazySingle{
    private LazySingle(){
        System.out.println(Thread.currentThread().getName());
    }
    //默认不初始化，调用的时候再初始化
    private static LazySingle instance;
    public static LazySingle getInstance(){
        if(instance== null){
            instance = new LazySingle();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试：多线程调用出现多次调用构造器，因此改进为加synchronized关键字。

懒汉式-同步代码块-不可用

忽略同步方法模式，直接使用同步代码块，粒度更小

//懒汉式，同步代码块
class LazySyncSingle{
    private LazySyncSingle(){
        System.out.println(Thread.currentThread().getName());
    }
    private volatile static LazySyncSingle instance;
    public static LazySyncSingle getInstance(){
        if(instance== null){
            synchronized (LazySyncSingle.class){
                instance = new LazySyncSingle();
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试：多线程下调用创建实例不能保证安全，假如一个线程进入了if 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

懒汉式-DCL-可用

//懒汉式，加锁双重校验
class LazySyncDoubleCheckSingle{
    private LazySyncDoubleCheckSingle(){
        System.out.println(Thread.currentThread().getName());
    }
    private static LazySyncDoubleCheckSingle instance;
    public static LazySyncDoubleCheckSingle getInstance(){
        //第一次校验
        if(instance== null){
            //class模板全局唯一
            synchronized (LazySyncDoubleCheckSingle.class){
                //第二次校验
                if(instance== null){
                    //不是原子操作指令重排会导致对象虚化
                    instance = new LazySyncDoubleCheckSingle();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

测试：多线程下结果和预期一致，只会调用一次构造器。

但是instance = new LazySyncDoubleCheckSingle()并不是一个原子操作，先研究下创建一个字符串执行了什么。

/**
 * @author my
 */
public class MySingle {
    public static void main(String[] args) {
    	String str = new String("a");
	}
}
1
2
3
4
5
6
7
8

找到class文件直接javap -c MySingle.class

一个对象的创建需要经历0 6 9 三个步骤，在一些极端情况下当线程1执行到0发生指令重排，指令9和6位置互换，即对象已经建立了关联关系但是并未执行6的init，此时线程2进来第一个if判断是否为null，此时已经不为null了，直接把创建了一半的对象返回了，这就是安全所在，要验证这个抱歉电脑太差模拟不出来，因此为了避免这种不安全的情况引入volatile关键字保证jvm在执行时不会发生指令重排。

JMM内存模型：

volatile:在编译期间，会在生成指令序列的时候，会在一些禁止重排序的地方，插入内存屏障从而禁止操作系统对指令进行重排序。

懒汉式-DCL+volatile-推荐

//懒汉式，加锁双重校验,禁止指令重排
class LazySyncDoubleCheckVolatitleSingle{
    private LazySyncDoubleCheckVolatitleSingle(){
        System.out.println(Thread.currentThread().getName());
    }
    //禁止指令重排
    private static volatile LazySyncDoubleCheckVolatitleSingle instance;
    public static LazySyncDoubleCheckVolatitleSingle getInstance(){
        if(instance== null){
            synchronized (LazySyncDoubleCheckVolatitleSingle.class){
                if(instance== null){
                    instance = new LazySyncDoubleCheckVolatitleSingle();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

反射破坏单例

/**
 * @author my
 */
public class MySingle {
    public static void main(String[] args) throws Exception {
        Constructor<LazySyncDoubleCheckVolatitleSingle> declaredConstructor =
            LazySyncDoubleCheckVolatitleSingle.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        LazySyncDoubleCheckVolatitleSingle instance1 = declaredConstructor.newInstance();
        LazySyncDoubleCheckVolatitleSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试：因此上面所讲的单例在一定程度上都是不可用的。

那么我们要如何去避免这种情况呢？

枚举

/**
 * @author my
 */
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        System.out.println(EnumSingle.INSTANCE);
        System.out.println(EnumSingle.INSTANCE);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试：两次生成的对象一样单例ok

反射破坏枚举单例

/**
 * @author my
 */
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        Constructor<EnumSingle> declaredConstructor = 
            EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        //NoSuchMethodException: com.example.studyjuc.EnumSingle.()
        System.out.println(declaredConstructor.newInstance());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

查看源码：应该报错是Cannot reflectively create enum objects才对呀

    @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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

反编译刚才那个类

javap -p EnumSingle.class
1

这里看到是有这个无参构造器但是为什么报错说没有呢？

说明这个反编译还是不是很理想，用jad反编译，发现有一个有参的构造器

jad -sjava EnumSingle.class
1

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

package com.example.studyjuc;


public final class EnumSingle extends Enum
{

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

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(com/example/studyjuc/EnumSingle, name);
    }
	//这个是什么，是有参的构造器呀
    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public EnumSingle getInstance()
    {
        return INSTANCE;
    }

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

修改反射

class Test{
    public static void main(String[] args) throws Exception {
        Constructor<EnumSingle> declaredConstructor = 
            EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        //NoSuchMethodException: com.example.studyjuc.EnumSingle.()
        System.out.println(declaredConstructor.newInstance());
    }
}
1
2
3
4
5
6
7
8
9

测试：因此发现枚举的单例是无法被破坏