单例模式——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();}}

这样就无法破解了。