单例模式

/**
 * @Description: 懒加载，线程不安全
 */
public class SingletonOne {
	private static SingletonOne instance = null;
	private SingletonOne() {
	}
	public static SingletonOne getInstance() {
		if (instance == null) {
			instance = new SingletonOne();
		}
		return instance;
	}
}

/**
 * @Description: 懒加载，线程安全，但性能较低
 */
public class SingletonTwo {
	private static SingletonTwo instance = null;
	private SingletonTwo() {
	}
	public static synchronized SingletonTwo getInstance() {
		if (instance == null) {
			instance = new SingletonTwo();
		}
		return instance;
	}
}

/**
 * @Description: 懒加载，线程安全，且高性能，双重校验锁（DCL，即 double-checked locking）
 */
public class SingletonThree {
	private volatile static SingletonThree instance = null;
	private SingletonThree() {
	}
	public static SingletonThree getInstance() {
		if (instance == null) {
			synchronized (SingletonThree.class) {
				if (instance == null) {
					instance = new SingletonThree();
				}
			}
		}
		return instance;
	}
}

/**
 * @Description: 懒加载，线程安全，使用静态内部类维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的
 */
public class SingletonFour {
	private SingletonFour() {
	}
	/**
	 * 此处使用一个内部类来维护单例
	 **/
	private static class SingletonFactory {
		private static final SingletonFour instance = new SingletonFour();
	}
	public static SingletonFour getInstance() {
		return SingletonFactory.instance;
	}
}

/**
 * @Description: 非懒加载，线程安全，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的
 */
public class SingletonFive {
	private static SingletonFive instance = new SingletonFive();
	private SingletonFive() {
	}
	public static SingletonFive getInstance() {
		return instance;
	}
}

/**
 * @Description: 非懒加载，线程安全，实现单例模式的最佳方法，更简洁，自动支持序列化机制，绝对防止多次实例化
 **/
public enum SingletonSix {
    INSTANCE;
    public SingletonSix getInstance() {
        return INSTANCE;
    }
}