单例模式

1.单例模式定义

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

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

2.单例模式结构

单例模式结构图中只包含一个单例角色：

Singleton（单例）：在单例类的内部实现只生成一个实例，同时它提供一个静态的 getInstance()工厂方法，让客户可以访问它的唯一实例；为了防止在外部对其实例化，将其构造函数设计为私有；在单例类内部定义了一个 Singleton 类型的静态对象，作为外部共享的唯一实例。

3.单例模式实例

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

实现代码

工程目录结构：

负载均衡器：单例类

package cn.red.singleton;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class LoadBalancer {
    //私有化静态成员变量，存储唯一实例
    private static LoadBalancer instance = null;
    //服务器集合
    private List<String> serverList = null;
    //私有化构造器
    private LoadBalancer() {
        serverList = new ArrayList<String>();
    }
    //公有静态成员方法，获得实例（懒汉式）
    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);
    }

}

客户端测试代码：

package cn.red.singleton;

public class Client {

    public static void main(String[] args) {
        //创建四个 LoadBalancer 对象
        LoadBalancer loadBalancer1,loadBalancer2,loadBalancer3,loadBalancer4;
        loadBalancer1 = LoadBalancer.getLoadBalancer();
        loadBalancer2 = LoadBalancer.getLoadBalancer();
        loadBalancer3 = LoadBalancer.getLoadBalancer();
        loadBalancer4 = LoadBalancer.getLoadBalancer();

        //判断服务器负载均衡器是否相同
        if(loadBalancer1 == loadBalancer2 && loadBalancer2 == loadBalancer3 && loadBalancer3 == loadBalancer4){
            System.out.println("服务器负载均衡器具有唯一性！");
        }

        //增加服务器
        loadBalancer1.addServer("server1");
        loadBalancer1.addServer("server2");
        loadBalancer1.addServer("server3");
        loadBalancer1.addServer("server4");

        //模拟客户端请求的分支
        for(int i = 0; i < 10; i++){
            String server = loadBalancer1.getServer();
            System.out.println("分发请求至服务器：" + server);
        }
    }

}

输出结果：

服务器负载均衡器具有唯一性！
分发请求至服务器：server1
分发请求至服务器：server3
分发请求至服务器：server3
分发请求至服务器：server2
分发请求至服务器：server2
分发请求至服务器：server3
分发请求至服务器：server4
分发请求至服务器：server2
分发请求至服务器：server4
分发请求至服务器：server3

4.饿汉式单例与懒汉式单例

（1）饿汉式单例

① 饿汉式单例结构图

② 饿汉式单例实现代码

package cn.red.singleton;

public 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。

② 懒汉式单例类代码

package cn.red.singleton;

public 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()时都需要进行线程锁定判断，在多线程高并发访问环境中，将会导致系统性能大大降低。如何既解决线程安全问题又不影响系统性能呢？我们继续对懒汉式单例进行改进。

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)判断，这种方式称为双重检查锁定。

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

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

5.单例模式总结

单例模式作为一种目标明确、结构简单、理解容易的设计模式，在软件开发中使用频率相当高，在很多应用软件和框架中都得以广泛应用。

（1）单例模式的主要优点：

① 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。

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

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

（2）单例模式的主要缺点：

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

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

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

6.单例模式适用场景

（1）系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

（2）客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。