单例模式-Singleton Pattern

单例模式-Singleton Pattern

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

单例模式有三个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

单例模式的结构如下图所：

举个实例

若要做一个服务器负载均衡(Load Balance)软件的开发，该软件运行在一台负载均衡服务器上，可以将并发访问和数据流量分发到服务器集群中的多台设备上进行并发处理，提高系统的整体处理能力，缩短响应时间。由于集群中的服务器需要动态删减，且客户端请求需要统一分发，因此需要确保负载均衡器的唯一性，只能有一个负载均衡器来负责服务器的管理和请求的分发，否则将会带来服务器状态的不一致以及请求分配冲突等问题。如何确保负载均衡器的唯一性是该软件成功的关键。

示意图如下：

实现代码如下：

import java.util.*;
//负载均衡器LoadBalancer：单例类，真实环境下该类将非常复杂，包括大量初始化的工作和业务方法，考虑到代码的可读性和易理解性，只列出部分与模式相关的核心代码

class LoadBalancer {
   //私有静态成员变量，存储唯一实例
   private static LoadBalancer instance = null;
   //服务器集合
   private List serverList = null;
  
    //私有构造函数
    private LoadBalancer() {
    serverList = new ArrayList();
    }
   
    //公有静态成员方法，返回唯一实例
    public static LoadBalancer getLoadBalancer() {
    if (instance == null) {
    instance = new LoadBalancer();
    }
    return instance;
    }
   
    //增加服务器
    public void addServer(String server) {
    serverList.add(server);
    }
   
    //删除服务器
    public void removeServer(String server) {
    serverList.remove(server);
    }
   
    //使用Random类随机获取服务器
    public String getServer() {
    Random random = new Random();
    int i = random.nextInt(serverList.size());
    return (String)serverList.get(i);
    }
    }

客户端代码如下：

class Client {
   public static void main(String args[]) {
   //创建四个LoadBalancer对象
   LoadBalancer balancer1,balancer2,balancer3,balancer4;
    balancer1 = LoadBalancer.getLoadBalancer();
    balancer2 = LoadBalancer.getLoadBalancer();
    balancer3 = LoadBalancer.getLoadBalancer();
    balancer4 = LoadBalancer.getLoadBalancer();
   
    //判断服务器负载均衡器是否相同
    if (balancer1 == balancer2 && balancer2 == balancer3 && balancer3 == balancer4) {
    System.out.println("服务器负载均衡器具有唯一性！");
    }
   
    //增加服务器
    balancer1.addServer("Server 1");
    balancer1.addServer("Server 2");
    balancer1.addServer("Server 3");
    balancer1.addServer("Server 4");
   
    //模拟客户端请求的分发
    for (int i = 0; i < 10; i++) {
    String server = balancer1.getServer();
    System.out.println("分发请求至服务器： " + server);
    }
    }
    }

输出结果如下：

分发请求至服务器： Server 1
   分发请求至服务器： Server 3
   分发请求至服务器： Server 4
   分发请求至服务器： Server 2
   分发请求至服务器： Server 3
   分发请求至服务器： Server 2
   分发请求至服务器： Server 3
   分发请求至服务器： Server 4
   分发请求至服务器： Server 4
   分发请求至服务器： Server 1

但是这样做有个问题

当第一次调用getLoadBalancer()方法创建并启动负载均衡器时，instance对象为null值，因此系统将执行代码instance= new LoadBalancer()，在此过程中，由于要对LoadBalancer进行大量初始化工作，需要一段时间来创建LoadBalancer对象。而在此时，如果再一次调用getLoadBalancer()方法（通常发生在多线程环境中），由于instance尚未创建成功，仍为null值，判断条件(instance== null)为真值，因此代码instance= new LoadBalancer()将再次执行，导致最终创建了多个instance对象，这违背了单例模式的初衷，也导致系统运行发生错误。

如何解决？我们有两种方案，饿汉式单例模式和懒汉式单例模式

1.饿汉式单例模式

结构图如下所示：

从图中可以看出，由于在定义静态变量的时候实例化单例类，因此在类加载的时候就已经创建了单例对象，代码如下所示：

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

当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。如果使用饿汉式单例来实现负载均衡器LoadBalancer类的设计，则不会出现创建多个单例对象的情况，可确保单例对象的唯一性。

2.懒汉式单例类与线程锁定

结构如下图所示：

从图中可以看出，懒汉式单例在第一次调用getInstance()方法时实例化，在类加载时并不自行实例化，这种技术又称为延迟加载(Lazy Load)技术，即需要的时候再加载实例，为了避免多个线程同时调用getInstance()方法，我们可以使用关键字synchronized，代码如下所示：

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

该懒汉式单例类在getInstance()方法前面增加了关键字synchronized进行线程锁，以处理多个线程同时访问的问题。但是，上述代码虽然解决了线程安全问题，但是每次调用getInstance()时都需要进行线程锁定判断，在多线程高并发访问环境中，将会导致系统性能大大降低。如何既解决线程安全问题又不影响系统性能呢？我们继续对懒汉式单例进行改进。事实上，我们无须对整个getInstance()方法进行锁定，只需对其中的代码“instance = new LazySingleton();”进行锁定即可。因此getInstance()方法可以进行如下改进：

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

问题貌似得以解决，事实并非如此。如果使用以上代码来实现单例，还是会存在单例对象不唯一。原
因如下：
假如在某一瞬间线程A和线程B都在调用getInstance()方法，此时instance对象为null值，均能
通过instance == null的判断。由于实现了synchronized加锁机制，线程A进入synchronized
锁定的代码中执行实例创建代码，线程B处于排队等待状态，必须等待线程A执行完毕后才可以进入synchronized锁定代码。但当A执行完毕时，线程B并不知道实例已经创建，将继续创建新的实例，导致产生多个单例对象，违背单例模式的设计思想，因此需要进行进一步改进，在synchronized中再进行一次(instance == null)判断，这种方式称为双重检查锁定(Double-CheckLocking)。使用双重检查锁定实现的懒汉式单例类完整代码如下所示：

class LazySingleton {
   private volatile static LazySingleton instance = null;
  
   private LazySingleton() { }
  
   public static LazySingleton getInstance() {
   //第一重判断
   if (instance == null) {
   //锁定代码块
    synchronized (LazySingleton.class) {
    //第二重判断
    if (instance == null) {
    instance = new LazySingleton(); //创建单例实例
    }
    }
    }
    return instance;
    }
    }

需要注意的是，如果使用双重检查锁定来实现懒汉式单例类，需要在静态成员变量instance之前增加修饰符volatile，被volatile修饰的成员变量可以确保多个线程都能够正确处理，且该代码只能在JDK 1.5及以上版本中才能正确执行。由于volatile关键字会屏蔽Java虚拟机所做的一些代码优化，可能会导致系统运行效率降低，因此即使使用双重检查锁定来实现单例模式也不是一种完美的实现方式。

3.比饿汉式和懒汉式更好的实现方式：IoDH

在IoDH中，我们在单例类中增加一个静态(static)内部类，在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用，实现代码如下所示：

//Initialization on Demand Holder
   class Singleton {
   private Singleton() {
   }
  
   private static class HolderClass {
   private final static Singleton instance = new Singleton();
   }
  
    public static Singleton getInstance() {
    return HolderClass.instance;
    }
   
    public static void main(String args[]) {
    Singleton s1, s2;
    s1 = Singleton.getInstance();
    s2 = Singleton.getInstance();
    System.out.println(s1==s2);
    }
    }

编译并运行上述代码，运行结果为：true，即创建的单例对象s1和s2为同一对象。由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例化Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

总结：

单例模式的优缺点

1.主要优点
单例模式的主要优点如下：
(1) 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。

(2) 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

(3) 允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多有损性能的问题。

2.主要缺点
单例模式的主要缺点如下：

(1) 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。

(2) 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。

(3) 现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。