设计模式之禅--1.单例模式

单例模式定义

Ensure a class has only one instance, and provide a global point of access to it.（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。）

单例模式的通用类图

演示代码

首先我们定义一个皇帝类，历史上所有的皇帝都希望自己的王朝中只有自己一个皇帝。

public class Emperor {
	private static final Emperor emperor=new Emperor();
	private Emperor() {
		//只能产生一个皇帝
	}
	public static Emperor getInstance() {
		return emperor;
	}
	//皇帝发话了
	public static void say() {
		System.out.println("我就是独一无二的皇帝");
	}
}

在定义大臣类，因为大臣要参拜皇帝，同时测试我们产生的皇帝是不是独一无二的。

public class Minister {
	public static void main(String[] args) {
		Emperor emperor0=Emperor.getInstance();
		for (int i = 0; i <5; i++) {
			Emperor emperor=Emperor.getInstance();
			emperor.say();
			System.out.println("我是独一无二的吗？"+(emperor==emperor0));
		}
	}
}

看看结果

我就是独一无二的皇帝
我是独一无二的吗？true
我就是独一无二的皇帝
我是独一无二的吗？true
我就是独一无二的皇帝
我是独一无二的吗？true
我就是独一无二的皇帝
我是独一无二的吗？true
我就是独一无二的皇帝
我是独一无二的吗？true

通过 结果我们看出了我们设计出的皇帝就是独一无二的。

 

实践技巧

由于单例模式设计简单，这里就不给出模板代码了，总结一下，单例模式有以下几个特点：

1.构造方法是私有的，防止被类外调用。

2.在类中声明一个private static实例，并且调用自己的私有构造方法。

3.有一个public static 的返回方法。

4.通过singleton.getsingleton()方法调用实例。

单例模式的线程安全写法

//懒汉式
public class SingletonDemo02 {

	//类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。
	private static SingletonDemo02 singletonDemo02;

	private SingletonDemo02() {
   
	}

	public synchronized static SingletonDemo02 getInstance() {
		if (singletonDemo02 == null) {
			singletonDemo02 = new SingletonDemo02();
		}
		return singletonDemo02;
	}

	public static void main(String[] args) {
		SingletonDemo02 s1 = SingletonDemo02.getInstance();
		SingletonDemo02 s2 = SingletonDemo02.getInstance();
		System.out.println(s1 == s2);
	}

}

// 静态内部类方式
public class SingletonDemo03 {
	private SingletonDemo03() {
		System.out.println("初始化..");
	}

	public static class SingletonClassInstance {
		private static final SingletonDemo03 singletonDemo03 = new SingletonDemo03();
	}

	// 方法没有同步
	public static SingletonDemo03 getInstance() {
		System.out.println("getInstance");
		return SingletonClassInstance.singletonDemo03;
	}

	public static void main(String[] args) {
		System.out.println("main");
		SingletonDemo03 s1 = SingletonDemo03.getInstance();
		SingletonDemo03 s2 = SingletonDemo03.getInstance();
		System.out.println(s1 == s2);
	}
}

//双重检验锁 双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。
public class SingletonDemo04 {
	private SingletonDemo04 singletonDemo04;
	private static boolean flag = false;

	private SingletonDemo04() {

		if (flag == false) {
			flag = !flag;
		} else {
			throw new RuntimeException("单例模式被侵犯！");
		}
	}

	public static void main(String[] args) {

	}

	public SingletonDemo04 getInstance() {
		if (singletonDemo04 == null) {
			synchronized (this) {
				if (singletonDemo04 == null) {
					singletonDemo04 = new SingletonDemo04();
				}
			}
		}
		return singletonDemo04;
	}

}

 

//使用枚举实现单例模式 优点:实现简单、枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞 缺点没有延迟加载
public class User {
	public static User getInstance() {
		return SingletonDemo04.INSTANCE.getInstance();
	}

	private static enum SingletonDemo04 {
		INSTANCE;
		// 枚举元素为单例
		private User user;

		private SingletonDemo04() {
			System.out.println("SingletonDemo04");
			user = new User();
		}

		public User getInstance() {
			return user;
		}
	}

	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		User u1 = User.getInstance();
		User u2 = User.getInstance();
		System.out.println(u1 == u2);
		
	}
}