详解单例设计模式

详解单例设计模式

系统用例

现在才知道，在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。

菜鸡单例写法

public class MyClass {

    private static MyClass instance;

    private MyClass() {
        //私有构造方法，不对外公开。
    }

    public static MyClass getInstance() {
        if (instance == null) {
             instance = new MyClass();
        }
        return instance;
    }
}

这个是最菜鸟的单例，然而我记得前年去京东面试的时候连这个还写不出。一年后的今天，其实我也就只会写这个

为什么说这种写法菜呢？因为虽然构造方法被声明为private，但是通过反射依然可以调用这个构造方法，生成MyClass的实例，而且这样也不会受到单例限制，可以无限创建对象，从而带来安全隐患。这里我也学到了一种黑技巧！

另外就是在并发场景中，多个线程调用getIntance()很可能会生成多个实例，这样也不符合单例的约束,更不符合线程安全。

这种写法在老鸟嘴巴中，被称作懒汉式单例，特点是首次调用getInstance()时才会创建对象，对内存占用相对合理。因为有时候业务逻辑可能根本不需要实力化对象，那么这时如果创建了对了，业务逻辑又用不到，就造成了内存的浪费。

所以，如果不想被称为菜，请不要这么写了！

线程安全的懒汉式单例

public class MyClass {

    private static MyClass instance;

    private MyClass() {
    }

    public synchronized static MyClass getInstance() {
        if (instance == null) {
             instance = new MyClass();
        }
        return instance;
    }
}

上面提到了菜鸟单例在并发场景下，线程安全的问题，那么有了问题当然就一定有解决方法。

java中一提到线程安全，我们理所应当会想到加锁！Java有两把锁，一种是基于jvm的synchronized，另一种是基于类库的lock，这里我们使用synchronized关键字给getInstance()加锁，强制所有线程阻塞调用getInstance()实现线程安全。

但是这里存在一个问题，getInstance()不仅仅用来实力化对象，还负责返回对象。当instance为空时，我们对他实力话操作的时候才需要加锁，而如果instance不为空时，我们不需要实力话，当然也不需要考虑线程安全，这时候需要也加锁，不就降低了效率吗？

线程安全升级版超级大懒汉

public class MyClass {

    private static MyClass instance;

    private MyClass() {
    }

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

饿汉式单例

public class MyClass {

    private static MyClass instance = new MyClass();

    private MyClass() {
    }

    public static MyClass getInstance() {
        return instance;
    }
}

与懒汉相对的，就是饿汉式写法，采用这种写法时，只要使用了MyClass这个类，而不管是否调用getInstance()方法，都会先创建instance对象。

从并发角度看，由于对象早已创建好，所以所有的线程调用getInstance获得得对象都是同一个，所以饿汉模式天生就是线程安全的！，但是仍然没有解决反射带来得安全问题。

强大到极点的懒饿汉式

public class MyClass {

    private MyClass(){}

    public static MyClass getInstance(){
        return MyClassHolder.instance;
    }

    private static class MyClassHolder{
        private final static MyClass instance = new MyClass();
    }
}

在上面我们分别接触到了单例设计模式的懒汉和饿汉写法，懒汉对内存使用比较合理，但处理并发却比较复杂，而且无法应对反射机制；饿汉天生线程安全，写法简单，但对内存占用不合理，而且也无法面对反射机制。那么我们把二者相结合，就能创造出一个又懒又饿，并且无比强大的汉子，我称之「懒饿汉」。

如上面代码，当我们调用getInstance()方法时，私有静态类MyClassHolder在被调用的时候才会创建MyClass的实例，而且因为有final关键字，instance是一个常量，只能被创建一次，最后再返回已经被初始化的instance·，而且以后instance`也不再接受实力化。

登记式单例

/**
 *  父类
 */
public class MyClass {

    private static Map<String, MyClass> map = new ArrayMap<>();

    static {
        MyClass single = new MyClass();
        map.put(single.getClass().getName(), single);
    }

    private MyClass() {
    }

    public static MyClass getInstance(String classFullName) {
        if (classFullName == null) {
            classFullName = MyClass.class.getName();
        }

        if (map.get(classFullName) == null) {
            try {
                map.put(classFullName, (MyClass) Class.forName(classFullName).newInstance());
            } catch (Exception e) {
                Log.e(MyClass.class.getName(), "getInstance: ", e);
            }
        }
        return map.get(classFullName);
    }
}


/**
*  子类中重写getInstance()方法
*/

public class SubClass extends MyClass {

    public static SubClass getInstance() {
        return (SubClass) SubClass.getInstance(SubClass.class.getName());
    }
}

最后有一个问题，在继承关系中，如果所有的子类对象都需要保持唯一，我们是否需要给每个子类都写一套单例？

当然不用，我们可以在父类中使用登记式写法。其实上面的代码也很简单易懂，就是依据Key判断value是否为空，如果为空就向静态的ArrayMap中登记上一个实例，否则直接返回value.

然后子类就方便了，由于父类中的getInstance(String classFullName)会被继承下来，所以我们可以在每个子类中再定一个一个静态方法，去调用自己集成来的getInstance(String classFullName)，并且把类全名作为参数传递就可以了。自己定义的方法原则上来说可以自由命名，但是为了与父类统一，所以我们也把这个静态方法声明为getInstance()，由于式无参方法，就可以与集成来的方法形成重载，这样调用方式就与父类一致了。

其实这种写法还可以依据业务逻辑进一步改良，比如可以把反射创建实例的方式改为使用构造方法，这样就可以提高效率；也可以不使用子类的getInstance()方法，而直接使用父类的getInstance(String classFullName)，获取到结果之后做强制转换，这样就不必在每个子类中额外定义静态方法了。

另外这种方式在并发时还是会出现问题，我们可以参照线程安全升级版超级大懒汉的方式来升级改造。

转载于:https://my.oschina.net/JiangTun/blog/1935264