设计模式（1）——单例模式

Heton_325

已于 2023-08-03 10:01:47 修改

阅读量51

点赞数

分类专栏：设计模式文章标签：设计模式单例模式

于 2023-08-03 10:00:20 首次发布

本文链接：https://blog.csdn.net/weixin_44287057/article/details/132077032

版权

设计模式专栏收录该内容

12 篇文章 0 订阅

订阅专栏

保证系统中某个类只有一个实例，所有操作都只能基于这个唯一的实例

1. 概述

这里仿照Windows任务管理器，进行一个建议的Java单例实现

public class TaskManager {
    
    private static TaskManager tm = null;
    
    private TaskManager(){}
    
    public void displayProcesses(){}   //显示进程
    
    public void displayServices(){}    //显示服务
    
    public static TaskManager getInstance(){
        if(tm == null){
            tm = new TaskManager();
        }
        return tm;
    }
}

将构造方法私有化，保证无法通过外部调用创建新实例
在类内创建静态变量tm存储我们需要得到的单一实例
对外提供静态方法getInstance创建这个实例，同时保证唯一性

第一次调用getInstance方法会创建实例并返回，后续再调用这个方法会返回已经创建过的这个实例，不会再次创建新实例，保证了实例的唯一性

单例模式的三个要点：

某个类只能有一个实例
它必须自行创建这个实例（即实例的创建是在该类内完成的，通过getInstance方法）
必须自行地向系统提供这个实例（把实例return出去）

2. 实践-负载均衡器的设计

将负载均衡器设计为单例模式，保证全局只有一个负载均衡器，其中包含一个存储所有服务器信息的集合serverList，每次在该集合中随机选择一台服务器使用，代码实现如下：

public class LoadBalancer {
    
    //私有的静态成员变量，存储唯一实例
    private static LoadBalancer instance = null;
    
    //服务器集合
    private List<String> serverList = null;
    
    //构造函数私有化
    private LoadBalancer(){
        serverList = new ArrayList<>();
    }
    
    //公有静态成员方法，返回唯一实例
    public static LoadBalancer getInstance(){
        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 serverList.get(i);
    }

}

编写测试类

public class LoadBalancerTest {
    public static void main(String[] args) {
        
        //创建4个Loadbalancer对象，后续验证是否为同一个
        LoadBalancer balancer1, balancer2, balancer3, balancer4;
        balancer1 = LoadBalancer.getInstance();
        balancer2 = LoadBalancer.getInstance();
        balancer3 = LoadBalancer.getInstance();
        balancer4 = LoadBalancer.getInstance();

        //判断上述4个对象是否指向同一个实例
        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);
        }
    }
}

测试结果如下：

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

3.1. 问题引出

在上面的负载均衡器程序中，如果有两个客户端同时启动，希望调用负载均衡器，同时访问getInstance方法

在第一个客户端调用负载均衡器的时候，发现instance为空，会自动创建实例

然而实例的创建需要时间，在创建实例的过程中，第二个客户端访问getInstance方法，发现此时instance仍然为空，那么第二个客户端同样也会尝试创建实例

而LoadBalance类中只能保存一个实例，两个客户端又分别创建了自己的实例，当getInstance执行完毕返回时，必然会有一个实例被另一个实例所覆盖，导致其中的一个客户端无法正常访问负载均衡器

3.2. 饿汉式单例

public class EagerSingleton {

    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton(){}

    public static EagerSingleton getInstance(){
        return instance;
    }
}

在定义静态变量的时候创建实例对象，因此在类加载的时候就已经创建了实例对象，getInstance方法不涉及创建实例，只是单纯地返回实例，自然避免了多次创建的问题

3.3. 饿汉式单例与线程锁定

懒汉式单例不会在类加载的时候创建实例，而是延后到第一次调用getInstance方法的时候，又称“懒加载”

为避免同时创建多个实例，可以用线程锁的方式，使实例的判空和创建具有原子性，但又会带来性能问题。

public class LazySingleton {

    private static LazySingleton instance = null;

    private LazySingleton(){};

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