设计模式之:单例模式

单例模式：单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

单例模式有三种：懒汉式单例，饿汉式单例，登记式单例。

 

1.懒汉式单例

public class SlackerSingleton {

	private static SlackerSingleton instance;

	private SlackerSingleton() {
	}

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

优点：第一次调用才初始化，避免内存浪费。

缺点：必须加锁synchronized 才能保证单例，（如果两个线程同时调用getInstance方法，会重复创建对象，可能就不是只有一个实例了）但加锁会影响效率。

 

2.饿汉式单例

public class HungrySingleton {

	private HungrySingleton() {
	}
	private static HungrySingleton instance = new HungrySingleton();

	public static HungrySingleton getInstance() {

		return instance;
	}
}

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

 

3.登记式模式（holder）

public class HolderSingleton {

	private HolderSingleton() {
	}

	public static HolderSingleton getInstance() {
		return Holder.SINGLETON;
	}

	private static class Holder {
		private static final HolderSingleton SINGLETON = new HolderSingleton();
	}
}

内部类只有在外部类被调用才加载，产生SINGLETON实例；又不用加锁。此模式有上述两个模式的优点，屏蔽了它们的缺点，是最好的单例模式。

 

反射会破坏单例：

	@Test
	public void testGetInstance() throws InstantiationException, IllegalAccessException, IllegalArgumentException,
			InvocationTargetException, NoSuchMethodException, SecurityException {
		Class<?> classType = HungrySingleton.class;
		Constructor<?> c = classType.getDeclaredConstructor(null);
		c.setAccessible(true);
		HungrySingleton h1 = (HungrySingleton) c.newInstance();
		HungrySingleton h2 = (HungrySingleton) c.newInstance();
		System.out.println(h1 == h2);
	}

输出结果为false，说明e1和e2不是同一个对象，到这里，单例模式不起作用。如果e1和e2都是指向同一个对象的，那么它们的引用值相等。

那如何避免反射破坏单例呢？可以在第二次实例化时抛异常，即在单例的私有构造方法内添加实例化的判断

public class HungrySingleton {

	private static boolean flag = false;

	private HungrySingleton() {
		synchronized (HungrySingleton.class) {
			System.out.println("try to instance");
			if (!flag) {
				System.out.println("first time to instance");
				flag = true;
			} else {
				throw new RuntimeException("has instanced");
			}
		}
	}

	private static HungrySingleton instance = new HungrySingleton();

	public static HungrySingleton getInstance() {

		return instance;
	}
}

分析：

1. a.因为，反射执行了，会创建一个对象。这时候，是不走静态方法getInstance的
2. b.然后，我们尝试去获得一个单例，会失败。因为，我们调用静态方法getInstance，会尝试创建一个实例。而此时，实例已经创建过了。这样，就可以保证只有一个实例。是达到效果了，但是，在这种情况下，反射先于静态方法getInstance执行。这导致，我们无法获得已经该实例。所以，其实这种方法，是不好的。除非，你可以保证，你的getInstance方法，一定先于反射代码执行。否则虽然有效果，但是你得不到指向该实例的引用。

序列化破坏单例：

	@Test
	public void testGetInstanceSer() throws IOException, ClassNotFoundException {
		SlackerSingleton s1 = null;
		SlackerSingleton s = SlackerSingleton.getInstance();
		FileOutputStream fos = new FileOutputStream("SlackerSingleton.obj");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s);
		oos.flush();
		oos.close();

		FileInputStream fis = new FileInputStream("SlackerSingleton.obj");
		ObjectInputStream ois = new ObjectInputStream(fis);
		s1 = (SlackerSingleton) ois.readObject();
		System.out.println(s == s1);
	}

输出结果为false(执行报错的同志，请注意，单例要实现序列化接口)。s和s1指向的对象不是同一个。

解决方案：在单例代码中添加如下方法：

private Object readResolve(){
return instance;
}