单例模式

单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

使用单例模式时，有三个要点：

（1）某个类只能有一个实例；
（2）该类必须自行创建这个实例；

（3）该类必须自行向整个系统提供这个实例。

 实现一：使用同步线程安全创建单例对象
在Singleton类中需要做三点处理：
（1）含有一个静态私有的共享对象实例对象，声明为static，类对象实例；
（2）构造方法显式声明为私有方式，即private声明方式，外部不能创建对象实例；
（3）含有一个获得单例对象的方法，即该类自行向整个系统提供这个实例。

创建一个类全局对象实例作为单例对象

还是需要上面讲的三个要点，一个全局共享对象实例，私有构造方法，定义一个获得单例对象的方法。不同的是，首先将全局共享对象实例化，在获得单例对象的方法中直接返回全局共享对象，而不使用synchronized关键字。

分类：

饿汉式：既然饿，那么在创建单例对象实例的时候就比较着急，饿了嘛，于是就在装载类的时候就创建单例对象实例；

public class Singleton1 {
protected Singleton1(){};

public static Singleton1 getIntance(){
return instance;
}
private static Singleton1 instance = new Singleton1();

}

懒汉式：既然懒，那么创建单例的对象实例的时候就不着急，会一直等到即将要使用单例对象实例的时候才会创建，懒人嘛，总会推脱不开的时候才采取真正执行工作，因此在装载对象的时候不创建对象实例。

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

延迟加载的思想

        单例模式的懒汉式实现方式体现了延迟加载的思想，什么是延迟加载呢？
        通俗点说，就是一开始不要加载资源或者数据，一直等，等到马上就要使用这个资源或者数据了，躲不过去了才加载，所以也称Lazy Load，不是懒惰啊，是“延迟加载”，这在实际开发中是一种很常见的思想，尽可能的节约资源。

缓存的思想

        单例模式的懒汉式实现还体现了缓存的思想，缓存也是实际开发中非常常见的功能。
        简单讲就是，如果某些资源或者数据会被频繁的使用，而这些资源或数据存储在系统外部，比如数据库、硬盘文件等，那么每次操作这些数据的时候都从数据库或者硬盘上去获取，速度会很慢，会造成性能问题。
        一个简单的解决方法就是：把这些数据缓存到内存里面，每次操作的时候，先到内存里面找，看有没有这些数据，如果有，那么就直接使用，如果没有那么就获取它，并设置到缓存中，下一次访问的时候就可以直接从内存中获取了。从而节省大量的时间，当然，缓存是一种典型的空间换时间的方案。

单例模式的优缺点

 

时间和空间
        比较上面两种写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，费判断的时间，当然，如果一直没有人使用的话，那就不会创建实例，节约内存空间。
        饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

线程安全考虑
      从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如说：有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能导致并发问题。

     饿汉式是线程安全的，因为虚拟机保证了只会装载一次，在装载类的时候是不会发生并发的。

如何实现懒汉式的线程安全呢？
        当然懒汉式也是可以实现线程安全的，只要加上synchronized即可。但是这样一来，会降低整个访问的速度，而且每次都要判断，也确实是稍微慢点。

双重检查加锁
        可以使用“双重检查加锁”的方式来实现，就可以既实现线程安全，又能够使性能不受到大的影响。那么什么是“双重检查加锁”机制呢？
        所谓双重检查加锁机制，指的是：并不是每次进入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;  
    }  
} 

这种实现方式既可使实现线程安全的创建实例，又不会对性能造成太大的影响，它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快运行速度。
         提示：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高，因此一般建议，没有特别的需要，不要使用。也就是说，虽然可以使用双重加锁机制来实现线程安全的单例，但并不建议大量采用，根据情况来选用吧。