单例模式（Singleton Pattern）

单例模式定义：确保一个类只有一个实例，并提供一个访问它的全局访问点

实现一（懒汉式）：

对getInstance()方法进行同步 ，线程安全，影响性能

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

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

每次进入getInstance方法都需要进行同步很影响性能，我们可以使用“双重锁定”来解决性能问题

public class Singleton {
    private static Singleton instance = null;

    private Singleton(){}

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

实现二（饿汉式）：

这种实现方式的问题是单例对象是在类初始化时完成初始化，如果单例对象的创建需要消耗较多的资源，创建完成后又不立即使用，将造成系统资源严重浪费

public class Singleton {
	private static Singleton instance = new Singleton();
	//private final static Singleton instance = new Singleton();也是可以的
	
	private Singleton(){}
	
	public static Singleton getInstance(){
		return instance;
	}
}

instance的创建过程是线程安全的，详见：http://blog.csdn.net/a19881029/article/details/17068191

 

实现三（这种实现方式被称为Initialization on demand holder）：

通过使用内部类，避免在类初始化时创建单例对象，而是将单例对象的创建推迟至第一次请求单例对象时完成，以达到延迟加载的效果。同时单例对象作为内部类的静态属性，这样可以保证单例对象的创建过程是线程安全的

这种实现方式的优势在于使用“延迟加载”的方式解决了实现二中单例对象创建过早浪费系统资源的问题

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