单例模式的优缺点

单例模式的优缺点

一、时间和空间

比较上面两种写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否须要建立实例，浪费判断的时间。固然，若是一直没有人使用的话，那就不会建立实例，则节约内存空间。

饿汉式是典型的空间换时间，当类装载的时候就会建立类实例，无论你用不用，先建立出来，而后每次调用的时候，就不须要再判断了，节省了运行时间。

二、线程安全

（1）从线程安全性上讲，不加同步的懒汉式是线程不安全的，好比，有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能致使并发问题。以下示例：

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

程序继续运行，两个线程都向前走了一步，以下：

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

（2）饿汉式是线程安全的，由于虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

（3）如何实现懒汉式的线程安全呢？

固然懒汉式也是能够实现线程安全的，只要加上synchronized便可，以下：

public static synchronized Singleton getInstance(){}

可是这样一来，会下降整个访问的速度，并且每次都要判断。那么有没有更好的方式来实现呢？

（4）双重检查加锁

可使用"双重检查加锁"的方式来实现，就能够既实现线程安全，又可以使性能不受到很大的影响。那么什么是"双重检查加锁"机制呢？

所谓双重检查加锁机制，指的是：并非每次进入getInstance方法都须要同步，而是先不一样步，进入方法事后，先检查实例是否存在，若是不存 在才进入下面的同步块，这是第一重检查。进入同步块事后，再次检查实例是否存在，若是不存在，就在同步的状况下建立一个实例，这是第二重检查。这样一来， 就只须要同步一次了，从而减小了屡次在同步状况下进行判断所浪费的时间。

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

看看代码可能会更加清楚些。示例代码以下：

    public class Singleton {  
        /**  
         * 对保存实例的变量添加volatile的修饰  
         */  
        private volatile static Singleton instance = null;  
        private Singleton(){  
        }  
        public static  Singleton getInstance(){  
            //先检查实例是否存在，若是不存在才进入下面的同步块  
            if(instance == null){  
                //同步块，线程安全地建立实例  
                synchronized(Singleton.class){  
                    //再次检查实例是否存在，若是不存在才真正地建立实例  
                    if(instance == null){  
                        instance = new Singleton();  
                    }  
                }  
            }  
            return instance;  
        }  
    } 

 

这种实现方式能够实现既线程安全地建立实例，而又不会对性能形成太大的影响。它只是在第一次建立实例的时候同步，之后就不须要同步了，从而加快了运行速度。