单例模式（Singleton Pattern）

单例模式：某一个类只有一个实例，并且是自己在类中实例化然后向整个系统提供这个实例。（就好比在你的一生里，媳妇只有一个）

public class Wife{
    private static final Wife mWife = new Wife();
    private Wife(){
        //私有化构造方法 不向外界提供可实例化
    }
    private static Wife getInstance(){
        return mWife;
    }
    private static void kiss(){
        System.out.println("xifu memeda~");
    }
}

实现起来还是很简单的，是吧，秒懂。那么单例模式有什么有点叻？

• 类在内存中只存在一实例，所以单例就减少了内存的开支，对于经常要创建销毁，无疑用单例对于优化还是不错的。
• 当对象的产生需要比较多的资源，如读取配置之类的，就可以直接通过产生一个单例对象，永驻内存中。
• 避免资源多重占用，比如在写文件操作时，只有一个实例，所以就避免了对同一个文件的写操作。
• 对，还有可以设置一个全局的访问点，共享变量访问，嗯…其实直接 static final 就OK了。

那缺点是what?

• 用单例的话就别想着扩展了，因为你目的是类在系统就仅仅存在一个，然而将类修改成 interface，abstract就不能被实例化了。
• 违反单一职责原则。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是单例取决于环境,单例模式把“要单例”和业务逻辑融合在一个类中。

使用场景：

• 当然是咱要求一个类实例唯一的时候
• 创建一个类对象消耗资源过多，如访问IO和Databases等资源
• 在整个项目或者系统中共享或访问数据
• 定义大量的静态常量和静态方法（一般就是Utils类中），我们一般还是直接 static final 的方式。

上面我们介绍的是被称为饿汉式的单例，但是在下面的代码中需要考虑线程同步的问题。

public class Wife{
    private static Wife mWife = null;
    private Wife(){
        //私有化构造方法 不向外界提供可实例化
    }
    private static Wife getInstance(){
        if(mWife == null){
            mWife = new Wife();
        }
        return mWife;
    }
    private static void kiss(){
        System.out.println("xifu memeda~");
    }
}

这段代码在高并发，就可能会产生多个媳妇（Wife实例），那可不行，咱就只要一个媳妇。所以可以这么改:

public class Wife{
    private static Wife mWife = null;
    private Wife(){
        //私有化构造方法 不向外界提供可实例化
    }
    private static Wife getInstance(){
        if(mWife == null){
            synchronized(Wife.class){
                if(mWife == null){
                    mWife = new Wife();
                }
            }
        }
        return mWife;
    }
    private static void kiss(){
        System.out.println("xifu memeda~");
    }
}

上面就是被称为懒汉式的单例。
当然也可以在方法声明的时候加入 synchronized 关键字，这样意味着方法每次在访问的时候都会被锁住，效率比较低。等同于

    synchronized(Wife.class){
        if(mWife == null){
            mWife = new Wife();
        }
    }

即在外层少了判断为空，自己掂量掂量就明白了。

有时候，有时候，媳妇在某些情况下还是可以有两个的吧？好像就是两个双胞胎嫁给同一个男人，或者某个国家，一堆媳妇。（别打我，媳妇大人）
这时候单例模式就不满足我们的需求，但是我们稍微的扩展一下：

public class Wife{
    private static int countNumOfWife;
    private static int maxNumOfWife = 2;//3,4,5,6,7,8,9... 
    private static ArrayList<String> nameList  = new ArrayList<String>();
    private static ArrayList<Wife> wifeList  =new ArrayList<Wife>();

    static{
        for (int i = 0; i < maxNumOfWife ; i++) {
            wifeList.add(new Wife("Wife " + (i+1)));
        }
    }
    private Wife(){

    }
    private Wife(String name){
        nameList.add(name);
    }
    public static Wife getInstance(){
        Random  random  =new Random();
        countNumOfWife = random.nextInt(maxNumOfWife );
        return wifeList.get(countNumOfWife);
    }
    private static void kiss(){
        System.out.println("xifu memeda~");
    }
}

这个也叫做多例模式。

在Android中，也有单例模式的实现。
比如组件管理服务ActivityManagerService，WindowsManagerService….这些服务在系统中注册，你需要的时候通过context.getSystemService(String name)获取。
源码解析不在本文范围内：可以参考
https://github.com/simple-android-framework-exchange/android_design_patterns_analysis/tree/master/singleton/mr.simple