Java单例模式

单例模式，即保证某个类最多只能有一个实例。

该模式的设计思想是：私有化对象的构造方法，使得无法外部调用；然后提供一个全局的方法在需要时来获得该对象；该对象只会在其类的内部被创建。根据对象创建的时间，单例模式的实现可以分为饿汉式和懒汉式。

饿汉式是在类加载时就先创建实例，而懒汉式则是在首次调用获得实例的方法时去创建实例。

饿汉式单例模式：

package com.my.pattern.singleton;

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

}

懒汉式单例模式：

package com.my.pattern.singleton;

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

饿汉式由于在类加载时就已经创建实例，则由Java虚拟机保证其是线程安全的。而懒汉式则是在调用获得实例方法时创建对象，不是线程安全的。如需实现线程安全，则可以在其getInstance方法加上synchronized限制。而另一种性能损失较小的方法，则只是在单例对象还未被创建时增加synchronized代码。

线程安全的懒汉式单例模式：

package com.my.pattern.singleton;

public class SingletonLazySafe {

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

使用Volatile修饰变量，则该变量不会被编译器优化，每次都会从内存中读取。因此不会出现由于内存与寄存器中变量值不同而造成的线程安全问题。

单例模式的另一种实现方式是采用静态内部类，该方式既有饿汉式的线程安全，又实现了懒汉式的延迟加载。

静态内部类的单例模式：

package com.my.pattern.singleton;

public class Singleton {

    private static class SingletonHolder{

    	public static Singleton singleton = new Singleton();
    
    }

    private Singleton(){}
    
    public static  Singleton getInstance(){
        return SingletonHolder.singleton;
    }

}

而Java中实现单例的最佳模式，是采用单元素的枚举类型，其中该元素就是唯一的实例。




本人此处只是简单总结学习，如果想了解单例模式，建议直接研读参考1和参考3的文章，深入浅出，详尽发散。

参考1：http://en.wikipedia.org/wiki/Singleton_pattern
参考2：http://l6259710.iteye.com/blog/1026950
参考3：http://www.cnblogs.com/sjms/archive/2010/08/27/1809759.html