JAVA设计模式 — 单例模式(Singleton)

定义：确保一个类仅有一个实例，并且提供一个访问它的全局访问点。

类型：对象创建型模式

单例模式的结构

Singleton：
负责创建Singleton类自己的唯一实例，并提供一个getInstance的方法，让外部来访问这个类的唯一实例。

单例模式应该是23种设计模式中最简单的一种模式了。它有以下几个要素：

• 私有的构造方法
• 私有静态的类自身实例引用
• 以自己实例为返回值的静态的公有的方法

        单例模式根据实例化对象时机的不同分为两种：一种是饿汉式单例，一种是懒汉式单例。饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；而懒汉式在调用取得实例方法的时候才会实例化对象。

懒汉式实现示例代码如下：

package com.example.test;

/**
 * 懒汉式单例实现的示例
 */
public class Singleton {
	/**
	 * 定义一个变量来存储创建好的类实例
	 */
	private static Singleton instance = null;   
	/**
	 * 私有化构造方法，可以在内部控制创建实例的数目
	 */
    private Singleton(){
    	
    }    
    /**
     * 定义一个方法来为客户端提供类实例
     * @return
     */
    public static synchronized Singleton getInstance(){    
    	//判断存储类实例的变量是否有值
        if(instance==null){ 
        	//如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
            instance = new Singleton();    
        }    
        return instance;    
    }  
    
    /**
     * 示意方法，单例可以有自己的操作
     */
    public void operation(){
    	//功能处理
    }
}

饿汉式实现示例代码如下：

package com.example.test.ch1;

/**
 * 饿汉式单例实现的示例
 */
public class Singleton {
	/**
	 * 定义一个变量来存储创建好的类实例,直接在这里创建类实例，只能创建一次
	 */
	private static Singleton instance = new Singleton();   
	/**
	 * 私有化构造方法，可以在内部控制创建实例的数目
	 */
    private Singleton(){
    	
    }    
    /**
     * 定义一个方法来为客户端提供类实例
     * @return
     */
    public static Singleton getInstance(){    
    	//直接使用已经创建好的类实例
        return instance;    
    }  
    
    /**
     * 示意方法，单例可以有自己的操作
     */
    public void operation(){
    	//功能处理
    }
}

单例模式的优缺点

1、时间和空间

比较以上两种写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，节省内存空间。

饿汉式是典型的空间换时间，当类被加载的时候就会创建类实例，不管你用不用都先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

2、线程安全

(1)、从线程安全上讲，不加同步的懒汉式是线程不安全的，而饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

(2)、如何实现懒汉式的线程安全

当然懒汉式也是可以实现线程安全的，只需要加上synchronized即可，如下：

public static synchronized Singleton getInstance(){    
    	//判断存储类实例的变量是否有值
        if(instance==null){ 
        	//如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
            instance = new Singleton();    
        }    
        return instance;    
    }

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

(3)、双重检查加锁

可以使用双重检查加锁 的方式来实现，就可以既实现线程安全，又能够使线程不受到很大的影响。

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

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

示例代码如下：

package com.example.test;

/**
 * 双重检查 单例实现的示例
 */
public class Singleton {
	/**
	 * 定义一个变量来存储创建好的类实例
	 */
	private volatile static Singleton instance = null;   
	/**
	 * 私有化构造方法，可以在内部控制创建实例的数目
	 */
    private Singleton(){
    	
    }    
    /**
     * 定义一个方法来为客户端提供类实例
     * @return
     */
    public static Singleton getInstance(){    
    	//先检查实例是否存在，如果不存在才进入下面的同步块
        if(instance==null){ 
        	synchronized (Singleton.class) {
        		//同步块，线程安全地创建实例
				if(instance==null){
					//再次检查实例是否存在，如果不存在才真正地创建实例
		            instance = new Singleton();    
				}
			}
        }    
        return instance;    
    }  
    
    /**
     * 示意方法，单例可以有自己的操作
     */
    public void operation(){
    	//功能处理
    }
}

一种更好的单例实现方式

根据上面的分析，常见的两种单例实现方式都存在小小的缺陷，那么有没有一种方案，既能够实现延迟加载，又能够实现线程安全呢？

要想简单的实现线程安全，可以采用静态初始化器的方式，它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来，不是会浪费一定的空间吗？因为这种实现方式，会在类装载的时候就初始化对象，不过你需不需要。

如果现在有一种方法能够让类装载的时候不去初始化对象，那不就解决问题了？一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例。这样一来，只要不使用到这个类级内部类，那就不好创建对象实例，从而同时实现延迟加载和线程安全。

这个解决方案被称为Lazy Initialization holder class模式，这个模式综合使用了Java类级内部类和多线程缺省同步锁的知识，很巧妙地同时实现了延迟加载和线程安全。

示例代码如下：

package com.example.test;


/**
 * Lazy Initialization holder class模式 示例
 */
public class Singleton {
	
	/**
	 * 类级内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，
	 * 而且只有被调用时才会装载，从而实现了延迟加载
	 */
	private static class SingletonHolder{
		/**
		 * 静态初始化器，由JVM来保证线程安全
		 */
		private static Singleton instance = new Singleton();  
	}
	
	/**
	 * 私有化构造方法，可以在内部控制创建实例的数目
	 */
    private Singleton(){
    	
    }    
    /**
     * 定义一个方法来为客户端提供类实例
     * @return
     */
    public static Singleton getInstance(){    
    	return SingletonHolder.instance;
    }  
}

单例模式的本质

单例模式的本质：控制实例的数目。

何时选用单例模式

建议在如下情况时，选用单例模式。

当需要控制一个类的实例只能有一个，而且客户只能从一个全局访问点访问它时，可以选用单例模式，这些功能恰好是单例模式所要解决的问题。