单例模式

单例模式

一、概念 #

• 什么是单例模式？

  单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

• 什么是单例？

  在当前进程中，通过单例模式创建的类有且只有一个实例。

二、特点 #

• 在Java应用中，单例模式能保证在一个JVM中，该对象有且只有一个实例存在。（单例类只能有一个实例）
• 构造器必须是私有的，外部类无法通过调用构造器方法创建该实例。（单例类必须自己创建自己的唯一实例）
• 没有公开的set方法，外部类无法调用set方法创建该实例。
• 提供一个公开的get方法获取唯一的这个实例。（单例类必须给所有其他对象提供这一实例）

三、优缺点 #

• 优点：
  • 某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。（在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例）
  • 省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
  • 系统中某些类，如spring中的controller，控制着处理流程，如果该类可以创建多个的话，系统完全乱了。
  • 避免了对资源的重复占用。（比如写文件操作）
• 缺点：
  • 没有借口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

四、介绍 #

• 意图：

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

• 主要解决：

  一个全局使用的类频繁地创建和销毁。

• 何时使用：

  当想控制实例数目，节省系统资源的时候。

• 如何解决：

  判断系统是否已经由这个单例，如果有则返回，如果没有则创建。

• 关键代码：

  构造函数是私有的。

• 应用实例：

  1.Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

  2.一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

• 使用场景：

  • 1.要求生产唯一序列号。
  • 2.WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
  • 3.创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

• 注意事项：

  getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

五、实现 #

1、饿汉式 #

• **是否Lazy初始化：**否
• **是否多线程安全：**是
• **实现难度：**容易
• **优点：**没有加锁，执行效率会提高
• **缺点：**类加载时就初始化，浪费内存
• **描述：**这种方式比较常用，但容易产生垃圾对象。它基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。
• 代码实现：

public class Singleton {
  // 创建一个实例对象
    private static Singleton instance = new Singleton();
    /**
     * 私有构造方法，防止被实例化
     */
    private Singleton(){}
    /**
     * 静态get方法
     */
    public static Singleton getInstance(){
        return instance;
    }
}

2、懒汉式（线程不安全） #

• **是否Lazy初始化：**是
• **是否多线程安全：**否
• **实现难度：**容易
• **描述：**这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁synchronized，所以严格意义上它并不算单例模式。这种方式lazy loading很明显，不要求线程安全，在多线程中不能正常工作。
• 代码实现：

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

• 线程安全问题分析：

如上图，在运行过程中可能存在这么一种情况：多个线程去调用getInstance方法来获取Singleton的实例，那么就有可能发生这样一种情况，当第一个线程在执行if(instance==null)时，此时instance是为null的进入语句。在还没有执行instance=new Singleton()时（此时instance是为null的），第二个线程也进入了if(instance==null)这个语句，因为之前进入这个语句的线程中还没有执行instance=new Singleton()，所以它会执行instance=new Singleton()来实例化Singleton对象，因为第二个线程也进入了if语句所以它会实例化Singleton对象。这样就导致了实例化了两个Singleton对象，导致线程不安全。

3、懒汉式（线程安全） #

• **是否Lazy初始化：**是

• **是否多线程安全：**是

• **实现难度：**容易

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

• **缺点：**必须加锁synchronized才能保证单例，但加锁会影响效率

• **描述：**这是一种典型的时间换空间的写法，不管三七二十一，每次创建实例时先锁起来，再进行判断，严重降低了系统的处理速度。这种方式具备很好的lazy loading，能够在多线程中很好的工作，但是，效率很低，99%情况下不需要同步。

  getInstance()的性能对应用程序不是很关键（该方法使用不太频繁）。

• 代码实现：

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

4、双检锁/双重校验锁（DCL，即double-checked locking） #

• **JDK版本：**JDK1.5起

• **是否Lazy初始化：**是

• **是否多线程安全：**是

• **实现难度：**较复杂

• **描述：**这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

  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;  
    }  
}

• 对volatile关键字分析：

  • volatile的作用：

    • 防止指令重排序，因为instance=new Singleton()不是原子操作
    • 保证内存可见
    • 通过volatile修饰的变量，不会被线程本地缓存，所有线程对该对象的读写都会第一时间同步到主内存，从而保证多线程间该对象的准确性

  • volatile的缺点：

    • volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不很高。

  • 如果不使用volatile会产生什么问题？

    有可能导致线程没有被初始化问题。

    在Java指令中创建对象和赋值操作是分开进行的，也就是说instance=new Singleton()语句是分两步执行的。

    但是JVM并不能保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。

    这样就可能出错了，我们以A、B两个线程为例：

    1.A、B线程同时进入了第一个if判断

    2.A首先进入synchronized块，由于instance为null，所以它执行instance=new Singleton()

    3.由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。

    

    4.B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

    5.此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。

5、登记式/静态内部类 #

• **是否Lazy初始化：**是

• **是否多线程安全：**是

• **实现难度：**一般

• **描述：**这种方式能达到双检锁方式一样的功效，但实现更简单，对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

  这种方式同样利用了classloader机制来保证初始化instance时只有一个线程，它跟第1种饿汉式方式不同的是：第1中方式只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonFactory类没有被主动使用，只有通过显示调用getInstance方法时，才会显示装载SingletonFactory类，从而实例化instance。想想一下，如果实例化instance很消耗资源，所以想让它延迟加载，另一方面，又不希望在Singleton类加载时就实例化，因为不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第1种饿汉式方式就显得很合理。

  使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。

• 代码实现：

public class Singleton {  
  
    /* 私有构造方法，防止被实例化 */  
    private Singleton() {  
    }  
  
    /* 此处使用一个内部类来维护单例 */  
    private static class SingletonFactory {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
  
    /* 获取实例 */  
    public static final Singleton getInstance() {  
        return SingletonFactory.INSTANCE;  
    }  
  
    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
    public Object readResolve() {  
        return getInstance();  
    }  
}  

6、枚举 #

• **JDK版本：**JDK1.5起

• **是否Lazy初始化：**否

• **是否多线程安全：**是

• **实现难度：**容易

• **描述：**这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

  这种方式是Effective Java坐着Josh Bloch提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于JDK1.5之后才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

  不能通过reflection attack来调用私有构造方法。

  使用枚举来实现单实例控制会更加简洁，而且JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

• 代码实现：

public enum Singleton {  
     /**
     * 定义一个枚举的元素，它就代表了Singleton的一个实例。
     */
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

六、总结 #

一般情况下，不建议使用第2种和第3种懒汉方式，建议使用第1中饿汉式方式。只有在要明确实现lazy loading效果时，才会使用第5种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第6中枚举方式。如果有其他特殊的需求，可以考虑使用第4中双检锁方式。

问题：为什么不用静态方法而用单例模式？

两者其实都能实现我们加载的最终目的，但是他们一个是基于对象，一个是面向对象的，就像我们不面向对象也能解决问题一样，面向对象的代码提供一个更好的编程思想。

如果一个方法和他所在类的实例对象无关，那么它就应该是静态的，反之他就应该是非静态的。如果我们确实应该使用非静态的方法，但是在创建类时又确实只需要维护一份实例时，就需要用单例模式了。

我们的电商系统中就有很多类，有很多配置和属性，这些配置和属性是一定存在了，又是公共的，同时需要在整个生命周期中都存在，所以只需要一份就行，这个时候如果需要我再需要的时候new一个，再给他分配值，显然是浪费内存并且再赋值没什么意义。

所以我们用单例模式或静态方法去维持一份这些值有且只有这一份值，但此时这些配置和属性又是通过面向对象的编码方式得到的，我们就应该使用单例模式，或者不是面向对象的，但他本身的属性应该是面对对象的，我们使用静态方法虽然能同样解决问题，但是最好的解决方案也应该是使用单例模式。