单例模式——Singleton Pattern

单例模式的核心作用就是保证一个类只有一个实例，并提供一个访问该实例的全局访问点【即提供一个public方法获取该实例】。

应用场景：

• Windows中的任务管理器
• 项目开发中，读取配置文件的类通常也是单例模式。
• 网站的计数器通常使用单例模式，否则不容易实现同步
• 数据库的连接池的设计一般采用单例模式。
• 在Spring中，每个Bean默认就是单例的，Spring MVC中，控制器对象也是单例的。
• Servlet编程中，Servlet也是单例的     

单例模式的优点：

由于单例模式只生成一个实例，减小了系统性能开销，当一个对象的产生需要较多的资源时，如读取配置，产生其他依赖对象，则可以通过在应用启动时直接创建一个单例对象，然后永久驻留内存的方式来解决。

常见的单例模式

1.饿汉式：线程安全，调用效率高，不能延时加载

2.懒汉式：线程安全，调用效率低，可以延时加载

3.双重检测锁：

4.静态内部类式：线程安全，调用效率高，可以延时加载

5.枚举单例：线程安全，调用效率高，不能延时加载，天然的单例。

• 饿汉式单例模式

public class SingletonDemo1 {

	//在加载类时，立即加载这个实例（没有延时加载的优势）。加载类时是天然线程安全的
	private static SingletonDemo1 instance = new SingletonDemo1();
	
	private SingletonDemo1(){
		
	}
	
	//方法没有同步，执行效率高
	public static SingletonDemo1 getInstance(){
		return instance;
	}
}

饿汉式单例模式就是在类加载的时候就将它的对象加载出来，不论是否需要这个类。当需要的时候，直接通过它的公共方法返回它的单例对象。

• 懒汉式单例模式

public class SingletonDemo2 {

	private static SingletonDemo2 instance = null;
	
	private SingletonDemo2(){
		
	}
	
	//添加通过，防止多个线程同时调用时创建多个对象
	public static synchronized SingletonDemo2 getInstance(){
		if(instance == null) {
			instance = new SingletonDemo2();
		}
		return instance;
	}
}

懒汉式单例模式可以实现延迟加载（就是需要的时候才进行加载）资源的利用率提高了，但是每次调用实例的时候都要进行同步，执行效率降低。

• 双重检查锁模式

public class SingletonDemo3 {

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

• 静态内部类的方式

public class SingletonDemo4 {

	private static class SingletonInstance{
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	
	public SingletonDemo4 getInstance(){
		return SingletonInstance.instance;
	}
	
	private SingletonDemo4(){
		
	}
}

外部类没有static属性，则不会像饿汉式一样，立即加载对象。只有调用getInstance()方法时，才会加载静态内部类，加载类时是线程安全的，instance是static、final类型，保证了内存中只有一个这样的实例存在，所以它兼具线程安全与延迟加载的优势。

• 枚举类型的方式

public enum SingletonDemo5 {

	//这个枚举元素本身就是单例
	INSTANCE;
	
	//添加自己的操作
	public void operation(){
		
	}
}

枚举类型是天然的单例模式，它是基于JVM实现的单例模式，避免了反射以及反序列化的漏洞，不过遗憾的是它没有实现懒加载。

上述的五种方法除了枚举类型实现的单例以外，其他的都可以通过反射以及序列化与反序列化进行破解。以懒汉式单例为例：

/**
 * 通过反射和反序列化来破解单例模式
 * @author acer
 *
 */
public class GetSingleton {

	public static void main(String[] args) throws Exception {
		SingletonDemo2 s1 = SingletonDemo2.getInstance();
		SingletonDemo2 s2 = SingletonDemo2.getInstance();
		System.out.println(s1);
		System.out.println(s2);
		
		/**
		 * 通过反射进行破解
		 */
		Class<SingletonDemo2> clazz = (Class<SingletonDemo2>) Class.forName("gof.singleton.SingletonDemo2");
		//得到它的构造方法
		Constructor<SingletonDemo2> s = clazz.getDeclaredConstructor(null);
		//跳过它的权限检查，可以调用私有的构造方法
		s.setAccessible(true);
		SingletonDemo2 s3 = s.newInstance();
		SingletonDemo2 s4 = s.newInstance();
		System.out.println(s3);
		System.out.println(s4);
		
		/**
		 * 通过序列化与反序列化进行破解
		 */
		FileOutputStream fos = new FileOutputStream("d:/a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s3);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo2 s5 = (SingletonDemo2) ois.readObject();
		System.out.println(s5);
		ois.close();
	}
}

通过上面的俩种方法就破解了单例模式，如果不想被破解，可以修改一下SingletonDemo2的私有构造方法，

private SingletonDemo2(){
		if(instance != null) {
			throw new RuntimeException();
		}
	}

这样就无法破解了。