设计模式：单例模式（静态内部类）

单例模式（静态内部类）

JVM装载外部类不会实例化外部类对象，装载内部类时候才会实例化外部类对象

三步：

1.构造器私有化
2.创建私有静态内部类，在静态内部类中创建私有静态对象实例
3.对外提供共有方法（以供外部调用），返回对象实例

代码示例和解释

/**
 * 单例模式：静态内部类实现（推荐使用）
 *    1.构造器私有化
 *    2.创建私有静态内部类，在静态内部类中创建私有静态对象实例
 *    3.对外提供共有方法（以供外部调用），返回对象实例
 */
public class SingletonTest {
	public static void main(String[] args){
		//单线程情况下没有问题
		/*Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(instance2.hashCode());*/
		System.out.println("=======多线程情况下=======");
		Runnable runnable = new Runnable() {
			@Override
			public void run() {
				Singleton instance1 = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName()+"  "+instance1.hashCode());
			}
		};
		
		for(int i = 1;i<=20;i++){
			new Thread(runnable).start();
		}
	}
}

class Singleton{
	//1.构造器私有化
	private Singleton(){
		
	}
	//2.创建静态内部类（该内部类在外部类Singleton被装载在的时候并不会也立即被装载）
	private static class MakeSingleton{
		//在静态类内部对外部类进行对象实例化
		private static final Singleton INSTANCE = new Singleton(); 
	}
	//3.对外提供公有方法，返回对象实例（只有在调用该公有方法getInstance()的时候才会去装载静态内部类，实例化外部类对象，实现了懒加载,而且外部类对象的实例化是基于JVM对内部类的装载机制，类装载只装载一次，保证单例，同时类装载是线程同步的所以是线程安全的）
	public static Singleton getInstance(){
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return MakeSingleton.INSTANCE;
	}
}

打印结果：

分析及优缺点：

只有在调用公有方法getInstance()的时候才会去装载静态内部类，实例化外部类对象，实现了懒加载，而且外部类对象的实例化是基于JVM对内部类的装载机制，类装载只装载一次，保证单例，同时类装载是线程同步的所以是线程安全的，推荐使用