Android面试设计模式之单例模式

在面试的时候面试官会问我们常用的一些设计模式，这里先介绍一下单例模式。

• 为什么要使用单例模式

1.控制资源的使用，通过线程同步来控制资源的并发访问；
2.控制实例产生的数量，达到节约系统资源；
3.作为通讯媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通讯。

• 有多少种单例模式

1.饿汉式

public class CustomSingleton {
    private static CustomSingleton instance = new CustomSingleton();

    /**
     * 私有默认构造子
     */
    private CustomSingleton() {
    }

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

上面的例子中，这个类被加载的时候，静态变量instance会被初始化，此时类的私有构造方法会调用。此时，单例的实例就会被创建出来。
其实我们很容易理解，饿汉式从字面上就能理解，这个类很饿，不管你用不用，在装载类的时候就创建对象的实例。

2.懒汉式

public class CustomSingleton {
    private static CustomSingleton instance = null;

    /**
     * 私有默认构造子
     */
    private CustomSingleton() {
    }

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

        return instance;
    }
}

上面的写法说明懒，每次实例化都会进行判断，看是否需要去创建实例。由于懒汉式的实现线程安全的，这样会降低整个访问的速度，好的我们继续接着看。

3.双重检查加锁

public class CustomSingleton {
    private static CustomSingleton instance = null;

    /**
     * 私有默认构造子
     */
    private CustomSingleton() {
    }

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

双重检查加锁。双重，大家都可以看到先进行第一重检查，判断实例是否存在，再进入同步代码块，然后第二次检查实例是否存在，如果不存在，就是同步的情况下创建一个实例，这样就可以不用在多次创建时在同步情况下进行判断所浪费的时间。这个实现线程安全，同时不太影响性能。

4.Lazy initialization holder class 静态内部类

public class CustomSingleton {

    private CustomSingleton() {
    }

    private static class CustomSingletonHolder {
        private static CustomSingleton instance = new CustomSingleton();
    }

    public static CustomSingleton getInstance() {
        return CustomSingletonHolder.instance;
    }
}

思路
　要想很简单地实现线程安全，可以采用静态初始化器的方式，它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来，不是会浪费一定的空间吗？因为这种实现方式，会在类装载的时候就初始化对象，不管你需不需要。
　如果现在有一种方法能够让类装载的时候不去初始化对象，那不就解决问题了？一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例。这样一来，只要不使用到这个类级内部类，那就不会创建对象实例，从而同时实现延迟加载和线程安全。

代码中，当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。
这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。

补相关基础知识：
什么是类级内部类
简单点说，类级内部类指的是，有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。
类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。
类级内部类中，可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。
类级内部类相当于其外部类的成员，只有在第一次被使用的时候才被会装载。

多线程缺省同步锁的知识
　　大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：
　　1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时
　　2.访问final字段时
　　3.在创建线程之前创建对象时
　　4.线程可以看见它将要处理的对象时

---

这个单例模式是十分常用的，大家一定要清楚其原理再使用。