设计模式Part7——单例模式

Laker404

于 2022-04-12 14:05:58 发布

阅读量630

点赞数 2

文章标签：单例模式 c#

本文链接：https://blog.csdn.net/leikang111/article/details/124121650

版权

单例模式是结构最简单的设计模式，在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以确保系统中的一个类只有一个实例，而且该实例易被外界访问，从而方便对实例个数进行控制。

一、单例模式的概述

对于一个软件系统而言，只有一个实例很重要。例如一个系统只能有一个窗口管理器、一个计时工具、一个ID生成器，Windows操作系统只能打开一个任务管理器窗口，如果不使用机制对窗口对象进行唯一化，势必会打开多个窗口

定义一个统一的全局变量可以确保对象随时都能被访问，但不能防止创建多个对象

学习难度：⭐ 使用频率：⭐⭐⭐⭐

定义：确保一个类只有一个实例，并提供一个全局访问点来访问这个实例

二、单例模式的结构和实现

1：单例模式的结构

单例模式只包含一个类，即单例类，其结构如下：
单例角色(Singleton)，在单例类的内部创建它的唯一实例，并通过静态方法GetInstance()让客户端可以使用它的唯一实例。可见性设置为private,并在单例类内部定义了一个Singleton类型的静态对象，作为供外部共享访问的唯一实例

2：单例模式的实现

单例模式的代码实现如下：

class Singleton
{
    private static Singleton instance=null;  //静态私有成员变量
    //私有构造函数
    private Singleton(){}

    //静态共有工厂方法，返回唯一实例
    public static Singleton GetInstance()
    {
        if(instance==null)
        {
            instance=new Singleton();
        }
        return instance;
    }
}

客户端测试代码：

using System;
class Program
{
    static void Main(string[] args)
    {
        Singleton s1=Singleton.GetInstance();
        Singleton s2=Singleton.GetInstance();
        //判断两个对象是否相同
        if(s1==s2)
        {
            Console.WriteLine("两个对象是相同实例。");
        }
        Console.Read();
    }
}

输出结果为：两个对象是相同实例

说明两次调用GetInstance()所获取的对象是同一实例对象，且无法在外部对SIngleton进行实例化

要注意：
①单例构造函数的可见性为private

②提供一个类型为自身的静态私有成员变量

③提供一个共有的静态工厂方法

三、单例模式的应用实例

实例：某公司需要开发一个服务器负载均衡软件，该软件运行在一台负载均衡服务器上，需要确保负载均衡器的唯一性，只能由一个负载均衡器来负责服务器的管理和请求分发，否则会产生冲突

将负载均衡器LoadBalancer设计为单例角色，其中包含一个存储服务器信息的集合serverList，每次在serverList中随机选择一台服务器来相应客户端要求

LoadBalancer:负载均衡器，充当单例角色

using System;
using System.Collections;
namespace SingletonSample
{
    class LoadBalancer
    {
        //私有静态成员变量，存储唯一实例
        private static LoadBalancer instance=null;
        //服务器集合
        private ArrayList serverList=null;
        //私有构造函数
        private LoadBalancer()
        {
            serverList=new ArrayList();
        }
        //共有静态成员方法，返回唯一实例
        public static LoadBalancer GetLoadBalancer()
        {
            if(instance==null)
            {
                instance= new LoadBalancer();
            }
            return instance;
        }
        //增加服务器
        public void AddServe(string server)
        {
            serverList.Add(server);
        }
        //删除服务器
        public void RemoveServer(string server)
        {
            serverList.Remove(server);
        }
        //使用Random类随机获取服务器
        public string GetServer()
        {
            Random random=new Random();
            int i =random.Next(serverList.Count);
            return serverList[i].ToString();
        }
    }
}

Program:客户端测试

using System;
namespace SingletonSample
{
    class Program
    {
        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)
            {
                Console.WriteLine("服务器负载均衡器具有唯一性！");
            }
            //增加服务器
            balancer1.AddServe("Server1");
            balancer1.AddServe("Server2");
            balancer1.AddServe("Server3");
            balancer1.AddServe("Server4");
            //模拟客户端请求的分发，如果输出结果为同一个Server，可以将i适当方法，例如改为i<100
            for(int i = 0; i < 10; i++) 
            {
                string server=balancer1.GetServer();
                Console.WriteLine("分发请求至服务器:"+server);
            }
            Console.Read();
        }
    }
}

结果：

服务器负载均衡器具有唯一性！
分发请求至服务器:Server1
分发请求至服务器:Server2
分发请求至服务器:Server4
分发请求至服务器:Server2
分发请求至服务器:Server3
分发请求至服务器:Server2
分发请求至服务器:Server2
分发请求至服务器:Server2
分发请求至服务器:Server4
分发请求至服务器:Server1

虽然创建了四个LoadBalanced对象，但是实际上是同一个对象，因此通过单例模式可以确保LoadBalancer对象的唯一性

四、饿汉式单例和懒汉式单例

1：饿汉式单例类

饿汉式单例类(Eager Singleton)是实现起来最简单的单例类，由于定义静态变量的时候实例了单例类，因此在类加载时单例对象就已创建，代码如下：

class EagerSingleton
{
    private static EagerSingleton instance=new EagerSingleton();
    private EagerSingleton(){}
    private static EagerSingleton GetInstance()
    {
        return instance;
    }
}

2：懒汉式单例类与双重检查锁定

与饿汉式单例类相同的是，懒汉式单例类(Lazy Singleton)，不同点是，懒汉式单例类在第一次被引用时将自己实例化，在懒汉式单例类被加载时，不会将自己实例化。

但是懒汉式单例类有一个严重的问题，如果存在高并发、多线程的环境下，可能会造成创建多个实例对象，修改后的懒汉式单例类代码如下：

class LazySingleton
{
    private static LazySingleton instance=null;
    //程序运行时创建一个静态只读的辅助对象
    private static readonly object syncRoot=new Object();
    private LazySingleton(){}
    public static LazySingleton GetInstance()
    {
        //第一次判断，判断实例是否存在，不存在再加锁
        if(instance==null)
        {
            //加锁的程序某一时刻只允许一个线程访问
            lock(syncRoot)
            {
                //第二重判断
                if(instance==null )
                {
                    instance=new LazySingleton();  //创建单例实例
                }
            }
        }
        return instance;
    }
}

为了更好的对单例对象的创建进行控制，此处使用了一种被称为双重检查锁定的双重判断机制，该机制中，当实例不存在且同时又两个线程调用GetInstance方法时，它们都可以通过第一重判断，并由于Lock锁定机制，只有一个线程进入lock中执行创建代码，另一个处于排队状态。