单例模式（Singleton Pattern）

定义

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点（静态方法）。单例模式属于创建型模式。常见的ServletContext、ServletContextConfig、ApplicationContext以及数据库的连接池等都是以单例形式存在的。

常见的单例模式

• 饿汉式
  饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线程还没出现以前就是实例化了，不会存在访问安全问题。
  优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
  缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存空间。
  
  
  

代码示例如下：

public class HungrySingleton {
	private static final HungrySingleton hungrySingleton = new HungrySingleton();
	private HungrySingleton(){}
	//全局访问点
	public static HungrySingleton getInstance(){
    	return hungrySingleton;
	}
}

还可以利用静态代码块来实现：

public class HungryStaticSingleton {
	private static final HungryStaticSingleton hungrySingleton;
	static {
		hungrySingleton = new HungryStaticSingleton();
	}
	private HungryStaticSingleton(){}
	public static HungryStaticSingleton getInstance(){
		return hungrySingleton;
	}
}

• 懒汉式
  懒汉式单例是在被外部类调用时才创建实例。
  示例如下：
  
  

public class LazySimpleSingleton {
	private LazySimpleSingleton(){}
	private static LazySimpleSingleton lazy = null;
	public static LazySimpleSingleton getInstance(){
		if(lazy == null){
			lazy = new LazySimpleSingleton();
		}
	return lazy;
	}
}

不过，上面的单例存在线程安全隐患，为了保证线程安全，我们可以采用双重检查锁的机制：

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

但是，用到synchronized关键字，总归是要上锁，对程序性能还是存在一定影响的。我们可以从类初始化角度来考虑，采用静态内部类的方式：

public class LazyInnerClassSingleton {
	private LazyInnerClassSingleton(){}
	public static final LazyInnerClassSingleton getInstance(){
		return LazyHolder.LAZY;
	}
	private static class LazyHolder{
		private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
	}
}