第三条建议：用私有构造器和枚举强化Singleton属性

一、第一种实现Singleton的方式

示例：

public class MyThreadPool {
	//第二步：创建公有的唯一的自己的实例
	public static final MyThreadPool POOL = new MyThreadPool();
	
	private static ExecutorService executor;
	private static final int CORE_SIZE = Runtime.getRuntime().availableProcessors();
	//第一步：创建私有的构造方法
	private MyThreadPool(){
		executor = Executors.newFixedThreadPool(CORE_SIZE+1);
	}
	
	public void exec(Runnable runnable){
		executor.execute(runnable);
	}
}

这种方法的变种：

public class MyThreadPool {
	//第二步：创建私有的自己的成员变量
	private static final MyThreadPool MY_THREAD_POOL = new MyThreadPool();
	
	private static ExecutorService executor;
	private static final int CORE_SIZE = Runtime.getRuntime().availableProcessors();
	//第一步：创建私有的构造方法
	private MyThreadPool(){
		executor = Executors.newFixedThreadPool(CORE_SIZE+1);
	}
	
	//第三步：通过公有静态方法，返回实例
	public static MyThreadPool getInstance(){
		return MY_THREAD_POOL;
	}
}

差别就是：

使用的时候是直接使用成员变量

MyThreadPool pool= MyThreadPool.POOL

还是直接使用方法

MyThreadPool pool = MyThreadPool.getInstance();

二、第二种实现Singleton的方法

//第二步：创建私有的自己的成员变量
	private static MyThreadPool myThreadPool;
	
	private static ExecutorService executor;
	private static final int CORE_SIZE = Runtime.getRuntime().availableProcessors();
	//第一步：创建私有的构造方法
	private MyThreadPool(){
		executor = Executors.newFixedThreadPool(CORE_SIZE+1);
	}
	
	//第三步：创建公有的方法，如果没被创建则创建，如果被创建则返回自己的实例
	public MyThreadPool getInstance(){
		if (myThreadPool == null)
			myThreadPool = new MyThreadPool();
		return myThreadPool;
	}

但是当想使用序列化与反序列的时候，不光光要继承Serializable接口。因为如果进行反序列化，每次反序列化一个序列化的实例，就会生成新的实例。所以需要提供一个readResolve()（不太了解这部分。。。不知道原因）

所以为了能够反序列化，且反序列化只能生成唯一实例。直接采用Emnu类型就行了，就不需要写方法和继承了。

Enmu类型已经继承了Serializable并且重写了readResolve()。

示例：

public enum MyThreadPool {
	POOL;
	
	private ExecutorService executor;
	private final int CORE_SIZE = Runtime.getRuntime().availableProcessors();
	
	private MyThreadPool(){
		executor = Executors.newFixedThreadPool(CORE_SIZE+1);
	}
	
	public static MyThreadPool getInstance(){
		return POOL;
	}
}