单例模式

单例三要点

1. $类只能有一个实例（构造器私有化）$
2. $必须自行创建实例（静态变量保存唯一实例）$
3. $必须自行向整个系统提供这个实例（对外提供获取该实例的方法）$

饿汉式：类初始化时，直接创建实例对象，不存在线程安全问题

$直接实例化（简介直观）$

/*
饿汉式:
(1)构造器私有化
(2)自行创建，并且用静态变量保存
(3)向外提供这个获取实例方法
(4)用final修饰，强调这是一个单例
*/
public class Singleton1{
	public static final Singleton1 INSTANCE = new Singleton1();
	private Singleton1(){
	}
}

class Test1{
	public static void main(String[] args){
		Singleton1 s = Singleton1.INSTANCE;
	}
}

$枚举实现单例（简洁，而且防止被反射破坏）$

/*
枚举类型，表示该类型的对象是有限的
可以限定为一个，就成了单例
*/
public enum Singleton2{
	INSTANCE
}

class Test2{
	public static void main(String[] args){
		Singleton2 s = Singleton2.INSTANCE;
	}
}

$静态代码块（支持从外部文件获取实例信息）$

public class Singleton3{
	public static final Singleton3 INSTANCE;
	private String info;
	static{
		try{
			Properties pro = new Properties();
			//获取外部 single.properties 文件
			pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties");
			//获取 single.properties 文件中的 info 属性，实例化类
			INSTANCE = new Singleton3(pro.getProperty("info"));
		} catch (IOException e){
			throw new RuntimeException(e);
		}
	}
	private Singleton3(String info){
		this.info = info;
	}
}

懒汉式：延迟创建对象

构造器私有化
静态对象保存唯一实例
提供静态方法，获取实例

$双重检测锁（支持多线程）$

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

class Test4{
	public static void main(String[] args){
	
		Callable<Singleton4> c = new Callable<Singleton4>(){
			@Override
			public Singleton4 call() throws Exception{
				return Singleton4.getInstance();
			}
		};
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Singleton4> f1 = es.submit(c);
		Future<Singleton4> f2 = ex.submit(c);
		Singleton4 s1 = f1.get();
		Singleton4 s2 = f2.get();

		System.out.println(s1 == s2);
	}
}

$静态内部类形式（支持多线程）$

/*
在内部类被加载和初始化时，才创建INSTANCE实例对象
静态内部类不会自动随着外部类的加载和初始化而初始化，只有等到被调用时才加载和初始化。
因为实例在内部类加载和初始化时才创建，由于类加载器是唯一的，所以是线程安全的
*/
public class Singleton5{
	private Singleton5(){
	}
	private static class Inner{
		private static final Singleton5 INSTANCE = new Singleton5();
	}
	public static Singleton5 getInstance(){
		return Inner.INSTANCE;
	}
}

小结

饿汉式，枚举形式最简洁
懒汉式，静态内部类形式最简洁