设计模式-单例模式

单例模式其实就是想实现一个唯一的对象。

单例模式，Singleton Pattern,能够以其特有的优势，替代系统中全局变量，应用非常广泛。

1.意图
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
热门词汇：单例 唯一 私有构造

2.结构

android中有很多系统级别的全局变量，如时间，输入法，账户，状态栏等等，android中对这些都直接或者有些间接用到了单例模式。
以输入法为例，把上图修改为实际情况：

非常的简单，但是有一点，从上面我们也看到了synchronized关键字，在多线程的环境下，单例模式为了保证自己实例数量的唯一，必然会做并发控制。
类似这种线程安全的单例，跨进程的单例，参数化的单例等等的情况，确实超出本文的范围，而且都涉及到很多东西，是一个很大的话题，不好展开。

3. 代码：

public final class InputMethodManager {
    static final Object mInstanceSync = new Object();//同步
    //内部全局唯一实例
    static InputMethodManager mInstance;

    //对外api
    static public InputMethodManager getInstance(Context context) {
        return getInstance(context.getMainLooper());
    }

    /**
     * 内部api，供上面的外部api调用
     * @hide 系统隐藏的api
     */
    static public InputMethodManager getInstance(Looper mainLooper) {
        synchronized (mInstanceSync) {
            if (mInstance != null) {
                return mInstance;
            }
            IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
            IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
            mInstance = new InputMethodManager(service, mainLooper);
        }
        return mInstance;
    }
}

客户端调用，比如contextimpl中的getSystemService()方法中如下调用：

class ContextImpl extends Context{
    @Override
    public Object getSystemService(String name) {
        if (WINDOW_SERVICE.equals(name)) {
            //... ... 省略下面n个if，else if
        } else if (INPUT_METHOD_SERVICE.equals(name)) {
            //获取输入法管理者唯一实例
            return InputMethodManager.getInstance(this);
        }  else if (KEYGUARD_SERVICE.equals(name)) {
             //... ... 省略下面n个if，else if
        } else if (ACCESSIBILITY_SERVICE.equals(name)) {
            //又见单例，无处不在
            return AccessibilityManager.getInstance(this);
        } else if (LOCATION_SERVICE.equals(name)) {
            //... ... 省略下面n个if，else if
        }  else if (NFC_SERVICE.equals(name)) {
            return getNfcManager();
        }
        return null;
    }
}

常用的单例模式格式：

1、饿汉式单例 

复制代码代码如下:

public class Singleton {
   private final static Singleton INSTANCE = new Singleton();

   private Singleton() { }

   public static Singleton getInstance() {
      return INSTANCE;
   }
}

2、借助内部类
属于懒汉式单例，因为Java机制规定，内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载（实现了lazy），而且其加载过程是线程安全的。内部类加载的时候实例化一次instance。

复制代码代码如下:

public class Singleton {

   private Singleton() { }

   private static class SingletonHolder {
      private final static Singleton INSTANCE = new Singleton();
   }

   public static Singleton getInstance() {
      return SingletonHolder.INSTANCE;
   }
}

3、普通加锁解决

复制代码代码如下:

public class Singleton {
   private static Singleton instance = null;

   private Singleton() { }

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

      return instance;
   }
}

虽然解决了线程安全问题，但是每个线程调用getInstance都要加锁，我们想要只在第一次调用getInstance时加锁，请看下面的双重检测方案

4、双重检测，但要注意写法

复制代码代码如下:

public class Singleton {
   private static Singleton instance = null;

   private Singleton() { }

   public static Singleton getInstance() {
      if(instance == null) {
         synchronzied(Singleton.class) {
            Singleton temp = instance;
            if(temp == null) {
               temp = new Singleton();
               instance = temp
            }
         }
      }

      return instance;
   }
}

由于指令重排序问题，所以不可以直接写成下面这样：
public class Singleton {
   private static Singleton instance = null;

   private Singleton() { }

   public static Singleton getInstance() {
      if(instance == null) {
         synchronzied(Singleton.class) {
            if(instance == null) {
               instance = new Singleton();
            }
         }
      }

      return instance;
   }
}

但是如果instance实例变量用volatile修饰就可以了，volatile修饰的话就可以确保instance = new Singleton();对应的指令不会重排序，如下的单例代码也是线程安全的：
public class Singleton {
   private static volatile Singleton instance = null;

   private Singleton() { }

   public static Singleton getInstance() {
      if(instance == null) {
         synchronzied(Singleton.class) {
            if(instance == null) {
               instance = new Singleton();
            }
         }
      }

      return instance;
   }
}