平时上班比较忙，我就周末给大家更新下。今天给大家带来的是——单例模式。这个模式相对来说比较简单一点，但是有几个点还是得说一下，我们可以将这些细节用到我们自己的程序中。本来不想讲的，但是我想把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;
}
}
看吧，代码是不是很简单。首先我们来看下什么是懒汉式，什么又是饿汉式。
懒汉式：顾名思义，很懒。不到最后一刻就不动。在我们代码里面就是到你用我的时候，我才创建，不用的时候，我就歇着。
饿汉式：顾名思义，饥渴。呸，换句话说，就是勤快吧。我在类初始化的时候就做好准备，时刻迎接着使用者。
不管是，懒汉式还是饿汉式。通过代码，我们都会发现一个特点。
- 在单例的类中，都会持有一个当前类的对象；
- 构造函数私有化；
- 提供一个访问该对象的静态方法。
这么理解呢？
我们可以将单例模式视为————垄断。对，没错就是垄断。我不会让你通过其他方法创建我，只能使用我自己创建的，所以私有化构造函数。既然只有我能创建，那么我会为你提供一个方法，让你通过合法途径得到这个对象，而不是通过歪门邪道。
好了，现在我们来看下不同的地方。
首先饿汉式没啥说的，我们忽略。主要看一下懒汉式的代码。
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
......
最后我们看一下较为正式的定义。
单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 （记住，是垄断，只能通过我的途径拿货）。
好了，今天就到这儿，下期见！
