Java深入理解设计模式 - 单例模式

设计模式

模式分类

1. 创建型模式（用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”）

   单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。

2. 结构性模式（用于描述如何将类或对象按某种布局组成更大的结构）

   适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

3. 行为性模式（用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责）

   模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

（一）单例模式

1. 概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.1 场景

控制系统中的实例数量，节省系统资源。

1.2 目标

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

1.3 思路

在系统中判断该实例是否存在，存在则返回，不存在则新创建。

1.4 优缺点与使用场景

1.4.1 优点

1. 实现了对唯一实例访问的可控。
2. 在单例模式中，系统内存只有一个对象，节约系统资源，减少内存开销，提高系统的性能（尤其市需要频繁创建销毁对象）。
3. 避免对资源的多重占用（当进行写文件操作时，单例模式下可以避免同时对文件进行写操作）。

1.4.2 缺点

1. 没有接口，不能继承，扩展较困难。而且接口对单例模式来说也没有意义，它要求自行实例化，而接口和抽象类是不能实例化的。
2. 单例模式与单一职责模式有冲突。类应该只关心内部逻辑，而不关心外面怎么样来实例化。

1.4.3 使用场景

1. Windows的Task Manager（任务管理器）就是很典型的单例模式。
2. 网站（web）计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来（确保线程安全）。
3. 创建的一个对象需要消耗的资源过多，比如I/O,（数据库）连接池，（多线程）线程池一般采用单例。（这里要注意：如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。 ）
4. 要求生产唯一序列号。
5. 定义大量静态常量和静态方法的类，比如工具类。
6. servlet编程中的servlet也是单例的。
7. spring容器中的bean管理默认单例。

2. 实现

（一）懒汉式（线程安全，可以延迟加载，调用效率不高，易破解）

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

此处不加 synchronized 也是最基本的实现方式，不能再多线程下正常工作，所以严格来说不算单例模式。

优点：第一次调用初始化，避免内存浪费，资源利用率提高。
缺点：synchronized同步锁大大降低执行效率（并发效率）。

（二）饿汉式（线程安全，不能延迟加载，调用效率高，易破解）

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

优点：没有synchronized修饰，提高执行效率。
缺点：由于饿汉模式是基于类加载机制避免了多线程的同步，所以初始化发生在类加载时，如果没有调用getInstance（），将会极大的浪费内存资源。

（三）双检锁/双重校验锁（线程安全，可以延迟加载，不推荐，易破解）

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

1. 引入DCL原因：

早起JVM性能上有待优化，延迟初始化可以避免高开销（用时再初始化），或降低程序启动时间。延迟初始化需要使用同步，但同步执行的速度慢。所以就先用 不同步来判断（一次为null，就new，所以之后基本不为null），这样大多数不为null 情况下就不耗时了。等new的时候，要保证原子性，所以再加锁。

2. 可能出现问题：

此模式保证了线程安全：原子性、可见性。 保证了原子性，却没有考虑可见性。由于jvm底层会进行指令重排序（指令重排序是为了优化指令，提高程序运行效率。指令重排序包括编译器重排序和运行时重排序。JVM规范规定，指令重排序可以在不影响单线程程序执行结果前提下进行）。

3. 解决：

在JDK1.5之后，可以使用volatile变量禁止指令重排序，让DCL生效，如上述代码，但也因此缺少特别的优势。

（四）静态内部类（线程安全，可以延迟加载，易破解）

 public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

优点：同样利用类加载机制避免多线程同步，但与饿汉式不同的是，饿汉式只要类被装载就会被实例化，而静态内部类需要显示调用getInstance（）才会被初始化，而不是发生在类装载时，这比饿汉模式更加节省内存空间，提高资源利用率，实现效果与DCL类似。

（五）枚举（线程安全，不能延迟加载，推荐，不能破解）

 public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

Effective Java 作者 Josh Bloch 提倡的方式
优点：能够避免多线程同步的问题，实现方式更加简洁，并且能够防止反序列化和反射机制破解。

破解及选择

1. 反射漏洞

SingletonDemo i1 = SingletonDemo.getInstance();
SingletonDemo i2 = SingletonDemo.getInstance();
System.out.println(i1);
System.out.println(i2);
     
//通过反射的方式直接调用私有构造器，将会生成新的对象

Class<SingletonDemo> clazz = (Class<SingletonDemo>) Class.forName("com.test.SingletonDemo");
Constructor<SingletonDemo> c = clazz.getDeclaredConstructor(null);
c.setAccessible(true);
SingletonDemo  i3 = c.newInstance();
SingletonDemo  i4 = c.newInstance();
System.out.println(i3);
System.out.println(i4);

2. 反序列化漏洞

//将实例代码写入test.txt。通过反序列化的方式可以重新构造该对象 

FileOutputStream fos = new FileOutputStream("c:/test.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s1);
oos.close();
fos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c:/test.txt"));
SingletonDemo i1 =  (SingletonDemo) ois.readObject();
SingletonDemo i2 =  (SingletonDemo) ois.readObject();
System.out.println(i1);
System.out.println(i2);

可以发现上述代码将会生成新的对象。

3. 如何选择
   通常我们选择饿汉模式实现单例的需求，只有在明确要求实现懒加载时使用静态内部类，如果想绝对安全的创建单例对象可以选择枚举，避免反射和发序列化带来的问题，DCL自行考量。