单例模式（新手推荐）

平时上班比较忙，我就周末给大家更新下。今天给大家带来的是——单例模式。这个模式相对来说比较简单一点，但是有几个点还是得说一下，我们可以将这些细节用到我们自己的程序中。本来不想讲的，但是我想把23种设计模式做成一个专题，以后大家不管是复习还是面试等，都可以有个参考。虽然写得并不好。

单例模式，听名字就能感觉出来，就是只能有一个实例存在。的确如此，你的感觉很正确。既然只能存在一个实例，那么这个实例在什么时候创建呢？问得好，我们看一下单例模式最常用的两种分类。

一 懒汉式

用什么能表达我对你的心？唯有代码，看下来。

public class SingleTask {

public static SingleTask mSingleTask = null;

private SingleTask(){};

public static SingleTask getNewInstance(){

    if(null == mSingleTask){
        mSingleTask = new SingleTask();
    }
    return mSingleTask;
}

}

二 饿汉式

public class SingleTask1 {

private static SingleTask1 mSingleTask1 = new SingleTask1();

private SingleTask1(){}

public static SingleTask1 getNewInstance(){

    return mSingleTask1;
}

}

看吧，代码是不是很简单。首先我们来看下什么是懒汉式，什么又是饿汉式。

懒汉式：顾名思义，很懒。不到最后一刻就不动。在我们代码里面就是到你用我的时候，我才创建，不用的时候，我就歇着。
饿汉式：顾名思义，饥渴。呸，换句话说，就是勤快吧。我在类初始化的时候就做好准备，时刻迎接着使用者。

不管是，懒汉式还是饿汉式。通过代码，我们都会发现一个特点。

1. 在单例的类中，都会持有一个当前类的对象；
2. 构造函数私有化；
3. 提供一个访问该对象的静态方法。

这么理解呢？

我们可以将单例模式视为————垄断。对，没错就是垄断。我不会让你通过其他方法创建我，只能使用我自己创建的，所以私有化构造函数。既然只有我能创建，那么我会为你提供一个方法，让你通过合法途径得到这个对象，而不是通过歪门邪道。

好了，现在我们来看下不同的地方。

首先饿汉式没啥说的，我们忽略。主要看一下懒汉式的代码。

public static SingleTask getNewInstance(){

    if(null == mSingleTask){
        mSingleTask = new SingleTask();
    }
    return mSingleTask;
}

我们这么做，会不会有什么问题？
问题当然会有，在单线程模式下当然不会有问题。在实际的问题中，我们可能就不是单线程这么简单了，往往会涉及到多线程。在多线程的时候就会很容易出现问题，会导致对象被重复创建，显然，违背了设计单例的初衷。那么怎么解决呢？

等等，这个地方我不知道大家有没有疑问？多线程真的会出问题吗？（因为我的博客的定位就是新手，所以为了解除大家的疑问，我写个代码验证下，消除大家的疑虑）。

懒汉式的困扰一

public class SingleTask {

public static SingleTask mSingleTask = null;
private static int time = 0;

private SingleTask(){
    System.out.println(time++);
};

public static SingleTask getNewInstance(){

    if(null == mSingleTask){
        mSingleTask = new SingleTask();
    }
    return mSingleTask;
}

public static void main(String[] args){

    for(int i=0;i<100;i++){

        new Thread(){

            @Override
            public void run(){

                SingleTask.getNewInstance();
            }
        }.start();
    }
}
}

我在构造函数中，打印一句话，以此来证明确实被创建多次了。

让我们看看结果：

我随便运行几次，就已经这样了。证明代码确实是有问题的。那么如何改进呢？

有人肯定会说，我知道，加锁。好的，我们加锁。

public static SingleTask getNewInstance() {

    synchronized (SingleTask.class) {
        if (null == mSingleTask) {

            mSingleTask = new SingleTask();
        }
    }

    return mSingleTask;
}
// 其他部分代码不变的

来我们先运行下，用事实说话。

运行到你手困，结果只是调用一次。啊，好高兴啊，终于解决了。我们来分析下这段代码？

假设现在有三个饥渴的线程A,B,C来拿东西了。想象一下画面有助于增强印象。他们几乎同时来到位置1。看到门上有一把锁，所以只能放一个进去。他们商量了下，B进去了（实际上谁进去并不确定）。B来到位置2，发现mSingleTask = null，所以来到位置3，创建对象咯。创建完走出去了。紧接着A，C两个商量了下，C进去了。发现mSingleTask已经不为空了，很高兴直接拿着跑了。最后剩下A，等待好久终于进去了，和C一样，偷完就跑真刺激。

问题是解决了，本着处女座的原则。我们继续分析下代码看有没有可以升华革命友谊的地方。

懒汉式的困扰二

既然是锁，那么肯定会带来一定的开销，我们每次来的时候都要加锁，这个代价可想而知。那么能有什么解决办法吗？
当然，我是谁，我是不一样的烟火。

public static SingleTask getNewInstance() {

    if (null == mSingleTask) {
        synchronized (SingleTask.class) {

            if (null == mSingleTask) {

                mSingleTask = new SingleTask();
            }
        }
    }
    return mSingleTask;
}

可以看到，我们加了双重判空。这样，只有在mSingleTask = null的情况下才会加锁，然后苦苦等待对象创建完成。好了吧，当mSingleTask被赋予了新的生命后就不需要再次加锁。

三 静态内部类

public class SingleTask2 {

private static SingleTask2 mSingleTask2;
private SingleTask2(){
    //System.out.println("new instance");
}

public static SingleTask2 getSingleInstance() {

    return SingleTaskHolder.instance;
}


static class SingleTaskHolder {

    // 内部类初始化单例实例
    private static SingleTask2 instance = new SingleTask2();

}

// 验证下
public static void main(String[] args){

    for(int i=0;i<100;i++){
        new Thread(){

            @Override
            public void run(){
                SingleTask2.getSingleInstance();
            }
        }.start();

    }   
}
}

通过这种方式我们也能实现单例模式，那么这么做的原理是什么呢？
因为静态内部类只会被加载一次，所以这么做也是线程安全的。

好了，听你吹了这么长时间。这个模式有用吗？使用场景举个例子。

其他的不说，就说一个Android中的Application
……

最后我们看一下较为正式的定义。

单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 （记住，是垄断，只能通过我的途径拿货）。

好了，今天就到这儿，下期见！