你真的了解单例吗

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_26880973/article/details/80930628

    又到了一个老生常谈的话题,单例模式,可能在面试时我们也经常会遇到,但是看似很简单的问题,却能看出一个人对单例理解的深度。要写一个单例,首先需要让构造器私有,还需要对外提供一个可以获取单例的一个入口,通常我们可能会这样写:

第一种:

public class SingleTon {

    private static SingleTon instance = new SingleTon();

    private SingleTon(){}

    public static SingleTon get(){
        return instance;
    }
}

这种方式简单直接,实例随着类加载而加载,很方便,但是却不友好,有时候我们虽然加载了类,却没有使用该类实例的时候,会造成内存的浪费,不能达到懒加载的能力。所以我们可以改进成下面这样:

第二种:

public class SingleTon {

    private static SingleTon instance = null;

    private SingleTon(){}

    public static SingleTon get(){
        if (instance == null){
            instance =new SingleTon();
        }
        return instance;
    }
}

这样可以达到懒加载,需要的时候在初始化,但是如果在多线程的情况下是不完全的,那我们会这样写:

public class SingleTon {

    private static SingleTon instance = null;

    private SingleTon(){}

    public static synchronized SingleTon get(){
        if (instance == null){
            instance =new SingleTon();
        }
        return instance;
    }
}

虽然这样安全了,但是锁的粒度还是比较大,所以为了减小锁的粒度我们还会这样写:

public class SingleTon {

    private static SingleTon instance = null;

    private SingleTon() {
    }

    public static SingleTon get() {
        if (instance == null) {
            synchronized (SingleTon.class) {
                if (instance == null) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}
    如果我们写到这里就以为很满足了,那么我只能说太天真了,看似一切完美,但是我们还是要问自己,这样就绝对的会线程安全吗?

    要回答这个问题,这就不得不说一说对象的创建过程和java虚拟机的无序性。首先在我们new对象的时候,首先需要在方法区中去寻找该类的符号引用,如果找不到,说明类还没有被加载进虚拟机,所以需要通过类加载器先装载该类,通过加载,验证,准备,解析,初始化等操作,然后为对象在堆上开辟内存空间(1),对象初始化操作(2),然后在将栈上的引用指向该对象内存地址(3)。重点就在这,由于虚拟机的无序性,可能会造成执行的顺序并不是按照123进行的,也可能是按照132的执行顺序,结果就是引用先指向对象地址,然后对象在进行初始化等操作,这是由于线程的可见性造成的,所以为了保证变量instance的线程之间的可见性,我们需要将instance变量进行volatile修饰来解决instance的可见性问题。(关于java虚拟机的无序性和volatile的内存语义,涉及到了java内存模型的层面,这里暂时不过多分析,后面会单独进行讲解)。

所以正确的写法是这样:

public class SingleTon {

    private static volatile SingleTon instance = null;

    private SingleTon() {
    }

    public static SingleTon get() {
        if (instance == null) {
            synchronized (SingleTon.class) {
                if (instance == null) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}

我们还可以改成成一个类,专门生成单例:

public abstract class Singleton<T> {
    private volatile T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

那么到此我们就可以满足了吗?当然不能。

这里不可避免的需要对volatile进行解释一下了,volatile在《深入理解java虚拟机》中有一下几层含义:

1,被volatile修饰的变量,保证了该变量对其他线程的可见性,;

2,禁止指令重排序,虚拟机会通过插入很多读写内存屏障,来保证处理器不会乱序执行,但是也会造成编译器不会对代码进行优化(java内存模型会最大限度的保证程序并行执行),对效率有一定影响。

那么我们在不使用volatile的前提下如何优化呢,下面给出某大牛的写法:

public class SingleTon {

    private static SingleTon instance = null;

    private SingleTon() {
    }

    public static SingleTon get() {
        if (instance == null) {
            synchronized (SingleTon.class) {
                if (instance == null) {
                    SingleTon temp = null;
                    try {
                        temp = new SingleTon();
                    } catch (Exception e) {

                    }
                    if (temp != null)
                        instance = temp;
            }
        }
        return instance;
    }
}

看似无用的代码却大有用处,try的存在虚拟机无法优化temp是否为空,instance在赋值之前保证了对象已经初始化完成。看到这里明显感觉到水很深啊难过

       前面其实大概分为两种,饿汉式和懒汉式,那有没有既线程安全写法简单,又能懒加载呢?

第三种:

public class SingleTon {

    private SingleTon() {
    }

    private static class SingleHolder {
        private static SingleTon instance = new SingleTon();
    }

    public static SingleTon get() {
        return SingleHolder.instance;
    }
}

这里我们通过静态内部类来完成,是不是很妙,我们无需枷锁,外部类的加载不会造成内部类同时加载的,只有调用了get方法时才会加载内部类,创建对象,集前两种方法的优点于一身大笑

但是到这里我们又要分析了,以上写法到底完全不,如果通过反射或者反序列化还能保证是单例吗?

    当然不可能,在反射面前,一切都是小儿科了,这种写法可阻止不了反射,反序列化也不行,你必须重写readReslove方法,返回当前实例,不然就是多个实例了,

    那到底有没有绝对安全的单例啊,我们是不是都快绝望了,别急,放大招:

public enum  SingleTon {
    intstance;
}

是不是有点意外了,居然最简单最安全的是枚举,至于枚举是如何做到反射和反序列化时依然安全的可以看链接:

https://blog.csdn.net/gavin_dyson/article/details/70832185

好了,单例到此介绍完毕,看完这些你对单例模式真的了解了吗?

展开阅读全文

没有更多推荐了,返回首页