vlambda博客
学习文章列表

说实话，看到这个问题，我心里还是有点窃喜的~ 单例模式？不好意思，设计模式我只会单例，哈哈哈，看我一顿操作：

public class Singleton {
    private static Singleton singleton = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

感觉很easy啊，先是构造器私有化，防止外部创建实例，然后提供一个静态的方法，当实例不存在时，创建一个实例返回。但是我仔细一看，有问题。如果两个线程同时运行到if (singleton == null)那不就创建两个实例返回了吗？这可咋整？我灵机一动，想到了之前看到过的饿汉模式：

public class Singleton {
    private static Singleton singleton = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return singleton;
    }
}

是不是解决了线程不安全的问题？完美~

那么回到问题本身，如果预先创建对象的方式比较消耗系统资源，会拖延程序启动的速度。我如何在不预先创建对象的情况下设计一个单例模式呢？我们直接想到的方法是加一个synchronized关键字：

public class Singleton {
    private static Singleton singleton = null;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这可以说是很粗暴了，直接在静态方法上加synchronized，所有调用到这个方法的程序都需要排队一个一个执行，效率可以说是很低的，那么怎么提高效率呢？我们可以这么做：

public class Singleton {
    private static Singleton singleton = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

这是双重加锁机制，先判断对象是否存在，如果不存在，加锁后再次判断，如果还不存在，则创建新的对象。这样我们是不是就完全解决了线程安全问题？其实不是的，还有一个地方更需要注意。这涉及到JVM编译时的指令重排机制，什么是指令重排？singleton = new Singleton()，会被编译器编译成如下JVM指令：

memory = allocate();    //1：分配对象的内存空间 
ctorInstance(memory);  //2：初始化对象 
instance = memory;     //3：设置instance指向刚分配的内存地址

在实际运行的时候有可能顺序是这样的：

memory = allocate();    //1：分配对象的内存空间 
instance = memory;     //3：设置instance指向刚分配的内存地址 
ctorInstance(memory);  //2：初始化对象 

当线程A执行完1,3,时，instance对象还未完成初始化，但已经不再指向null。此时如果线程B抢占到CPU资源，执行  if（singleton == null）的结果会是false，从而返回一个没有初始化完成的singleton对象，也就是说获得了一个为null的对象。怎么避免这一情况呢？我们可以使用volatile关键字，禁止指令重排，线程安全的单例模式如下：

public class Singleton {
    private static volatile Singleton singleton = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

除了饿汉和懒汉模式之外还有两种创建单例的方法，第一种是静态内部类的方式，这也是一种延迟加载的方式去创建单例对象，不会造成系统资源的浪费，而且这种方式创建非常简单，线程安全，所以我比较推荐：

public class Singleton {  
    private static class SingletonHolder {  
     private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

第二种是枚举类，但是这种方式在平常开发的时候用的少，可读性不好，一般很少使用：

public enum Singleton  {
    INSTANCE      
    //可以省略此方法，通过Singleton.INSTANCE进行操作
    public static Singleton get Instance() {
        return Singleton.INSTANCE;
    }
}