单例单例还是单例模式

作者: MC_Honva | 来源:发表于2018-08-18 16:43 被阅读13次

【设计模式】单例模式
Android设计模式总结
IOS单例模式的底层原理
单例单例还是单例模式
IOS学习笔记之单例
OC - 单例模式
2018-04-08php实战设计模式
单例
JAVA多线程之线程安全的单例模式
设计模式之单例模式详解

单例说明图

饿汉式

public class Person {
    private Person() {
    }
    private static Person p=  new Person();
    public static Person getInstance(){
        return p;
    }
}

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。
饿汉式是线程安全的，因为虚拟机保证了只会装载一次，在装载类的时候是不会发生并发的。

懒汉式

public class Person {
    private Person() {
    }
    /**
     * 对保存实例的变量添加volatile的修饰
     */ 
    private volitile static Person p;
    public static synchorized Person getInstance(){
        if (p==null){
            p = new Person();
        }
        return p;
    }
}

懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，费判断的时间，当然，如果一直没有人使用的话，那就不会创建实例，节约内存空间。
因为懒汉式不加synchronized的话是线程不安全的，加了以后有会降低访问效率，所以产生了双重检查加锁，可以使用“双重检查加锁”的方式来实现，就可以既实现线程安全，又能够使性能不受到大的影响。

双重检查加锁机制

public class Singleton {

    private volatile static Singleton singleton = null; // 注意加上volatile关键字

    private Singleton(){
    }

    public static Singleton getInstance() {
        if (singleton == null) {    // 第一次检查
            synchronized (Singleton.class) {
                if (singleton == null) {    // 第二次检查
                    singleton = new Singleton();
                }
            }
        }
        return singleton ;
    }

}

该方法是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

双重检查加锁机制的实现会使用一个关键字volatile,被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

静态内部类模式

public class Singleton {
    //私有化构造函数，剥夺创建对象的权限
    private Singleton(){};
    //类的内部类，也就是静态内部类，该内部类的实例与外部类的实例没有绑定关系，而且只有在内部类被调用的时候才会装载，从而实现了延迟加载
    private static class SingletonHolder{
        //静态初始化，由JVM来保证线程安全
        private static final Singleton INSTANCE = new Singleton();
    }
    public static final Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

《Effective Java》推荐的单例模式写法，这种写法依靠Java内置机制保证单例。只不过写起来比较麻烦，而且容易出错。

使用枚举实现单例模式

public enum EnumSingleTon {
    /**
     * 其实枚举的变量相当于 public final stataic EnumSingleTon uniqueSingleTon = new
     * uniqueSingleTon();
     **/
    uniqueSingleTon;
    /**
     * 因为uniqueSingleTon已经成为了枚举的常量，所以就不会再改变，
     * 又因为枚举本身是一个语法级，虚拟机会提供枚举绝对不会被多次实例化的可能，而且枚举还有序列化的机制
     **/
    public void getInstance() {
        System.out.println(uniqueSingleTon.hashCode());
    }
}

更详细的说明参见大神文章：Java 利用枚举实现单例模式
在《高效Java 第二版》中说法：单元类的枚举类型已经成为了实现单例的最佳方法。