Java单例类 demo

不推荐使用Singleton1和Singleton2，Singleton3基本可以满足需求，Singleton5支持延迟加载，但是实现稍麻烦，Effective Java 作者推荐通过枚举实现单例，自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化

通过枚举实现单例

package com.basic.designpatterns.create.singleton;

/**
 * 单例
 *
 * @author chichuduxing
 * @date 2017年2月4日 下午4:40:22
 */

class Resource {
	// 具体业务.
	public void doSomeThing() {
		System.out.println("working");
	}
}

/**
 * 通过枚举类实现（枚举类中构造必须是私有的） 支持线程安全，支持序列化
 */
public enum EnumSingleton {

	INSTANCE;

	private Resource instance = null;

	private EnumSingleton() {
		instance = new Resource();
	}

	public Resource getInstance() {
		return instance;
	}
}

通过枚举实现单例，但是不暴露细节的单例类

package com.basic.designpatterns.create.singleton;

/**
 * @author chichuduxing
 * @date 2017年4月3日 下午7:54:42
 */

public class EnumFactory {

	/**
	 * 对外的获取单例的方法
	 *
	 * @return 单例对象
	 */
	public static SingResource getInstance() {
		return EnumSingleton.INSTANCE.getInstance();
	}

	/**
	 * 通过枚举类实现（枚举类中构造必须是私有的） 支持线程安全，支持序列化
	 */
	private enum EnumSingleton {

		INSTANCE;

		private SingResource instance = null;

		private EnumSingleton() {
			instance = new SingResource();
		}

		public SingResource getInstance() {
			return instance;
		}
	}

	/**
	 * 测试方法
	 *
	 * @param args
	 */
	public static void main(String[] args) {
		EnumFactory.getInstance().doSomeThing();
	}
}

/**
 * 具体实现功能的单例类
 */
class SingResource {
	public SingResource() {

	}

	// 具体业务.
	public void doSomeThing() {
		System.out.println("working");
	}
}

其他若干种实现方式

package com.basic.designpatterns.create.singleton;

/**
 * 单例模式
 *
 * @author chichuduxing
 * @date 2017年2月4日 上午11:19:02
 */

/**
 * 懒汉式，线程不安全
 */
class Singleton1 {

	private Singleton1() {

	}

	private static Singleton1 instance = null;

	public static Singleton1 getInstance() {
		if (null == instance) {
			return new Singleton1();
		}
		return instance;
	}

}

/**
 * 懒汉式，线程安全 效率低
 */
class Singleton2 {

	private Singleton2() {

	}

	private static Singleton2 instance = null;

	public static synchronized Singleton2 getInstance() {
		if (null == instance) {
			return new Singleton2();
		}
		return instance;
	}

}

/**
 * 饿汉式，(单个ClassLoader时线程安全) 无锁，线程安全，但是类加载时就会new对象.
 */

class Singleton3 {

	private Singleton3() {
	}

	private static Singleton3 instance = new Singleton3();

	public static Singleton3 getInstance() {
		return instance;
	}
}

/**
 * 双重锁校验 懒汉式，线程安全.需要加volatile关键字</br>
 * 因为instance = new Singleton4();并不是原子的操作，</br>
 * 如果处理器进行重排序后可能早晨instance虽然不为null了，但是实例还没初始化</br>
 */

class Singleton4 {

	private Singleton4() {
	}

	// 必选加volatile关键字
	private volatile static Singleton4 instance = null;

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

/**
 * 内部类，内部类是延时加载的，只会在第一次使用时加载，不使用就不加载。 懒汉式，线程安全.
 */
class Singleton5 {

	private Singleton5() {
	}

	static class InnerSingleton {
		private static final Singleton5 instance = new Singleton5();
	}

	public static final Singleton5 getInstance() {
		return InnerSingleton.instance;
	}

}

public class SingletonPatternDemo {
	// 推荐EnumSingleton
	// 其次Singleton5

	public static void main(String[] args) {
		EnumSingleton.INSTANCE.getInstance().doSomeThing();
	}
}