最新消息:XAMPP默认安装之后是很不安全的,我们只需要点击左方菜单的 "安全"选项,按照向导操作即可完成安全设置。

创建型-单例模式 SingletonPattern

XAMPP教程 admin 387浏览 0评论

单例模式 Singleton

  • 保证一个类只有一个实例的实现方法
  • 给其他类提供一个全局的访问点。
  • 由自己创建自己的唯一实例

实现

  • 实现方法分为饿汉式(线程安全)、懒汉式(线程不安全)、懒汉式(lock+双重验证、线程安全)、延迟加载(Lazy、线程安全)

1.饿汉式

这种方式比较常用,但容易产生垃圾对象.这时候初始化 instance 显然没有达到 lazy loading 的效果。优点:没有加锁,执行效率会提高。缺点:类加载时就初始化,浪费内存。

public class EagerSingleton
{
    private EagerSingleton() { }
    private static readonly EagerSingleton Instance = new EagerSingleton();

    public static EagerSingleton GetInstance()
    {
        return Instance;
    }
}

2.最简单的实现:懒汉式(线程不安全)

namespace Singleton
{
    public class Singleton
    {
        private static Singleton _uniqueInstance;

        private Singleton()
        {
        }

        public static Singleton GetInstance()
        {
            if (_uniqueInstance is null)
            {
                _uniqueInstance = new Singleton();
            }

            return _uniqueInstance;
        }
    }
}

定义了一个静态方法,作为全局访问点,在单线程下是正常的,在多线程同时运行GetInstance,得到的_uniqueInstance都是null,此时就会创建多个 定义了一个静态方法,作为全局访问点,在单线程下是正常的,在多线程同时运行GetInstance,得到的_uniqueInstance都是null,此时就会创建多个的实例。

多线程访问得到hash code是不一样的。

static void Main(string[] args)
{

    Task.Run(() =>
    {
        Singleton singleton = Singleton.GetInstance();
        Console.WriteLine(singleton.GetHashCode());
    });

    Task.Run(() =>
    {
        Singleton singleton = Singleton.GetInstance();
        Console.WriteLine(singleton.GetHashCode());
    });

    Console.WriteLine("over!");
}

over还提前输出。

over!
4032828
6044116
static void Main(string[] args)
{
    Singleton singleton1 = Singleton.GetInstance();
    Console.WriteLine(singleton1.GetHashCode());

    Singleton singleton2 = Singleton.GetInstance();
    Console.WriteLine(singleton2.GetHashCode());

    Console.WriteLine("over!");
}

输出

58225482
58225482
over!

3.懒汉式(lock+双重验证、线程安全)

lock关键字

MSDN介绍

lock 关键字可确保当一个线程位于代码的临界区时,另一个线程不会进入该临界区。 如果其他线程尝试进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放。
lock 关键字在块的开始处调用 Enter,而在块的结尾处调用 Exit。 ThreadInterruptedException 引发,如果 Interrupt 中断等待输入 lock 语句的线程。
通常,应避免锁定 public 类型,否则实例将超出代码的控制范围。

常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 违反此准则:
如果实例可以被公共访问,将出现 lock (this) 问题。
如果 MyType 可以被公共访问,将出现 lock (typeof (MyType)) 问题。
由于进程中使用同一字符串的任何其他代码都将共享同一个锁,所以出现 lock("myLock") 问题。
最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。
在 lock 语句的正文不能使用 等待 关键字。

最常使用的锁是如下格式的代码段:

private static object objlock = new object();
lock (objlock )
{
    //要执行的代码逻辑
}

使用lock关键字解决多线程问题

public static LockSingleton GetInstance()
{
    // 当第一个线程运行到这里时,此时会对locker对象 "加锁",
    // 当第二个线程运行该方法时,首先检测到locker对象为"加锁"状态,该线程就会挂起等待第一个线程解锁
    // lock语句运行完之后(即线程运行完之后)会对该对象"解锁"
    lock (Locker)
    {
        // 如果类的实例不存在则创建,否则直接返回
        if (_uniqueInstance == null)
        {
            _uniqueInstance = new LockSingleton();
        }
    }
    return _uniqueInstance;
}

在lock之前判断是否实例

上面的代码还可以优化,通过判断对象是否为null,如果不是null,则直接返回,否则先锁,然后再生成实例,保证不同线程访问得到的是一个实例

public static LockSingleton GetInstance()
{
    // 双重锁定只需要一句判断就可以了
    if (_uniqueInstance == null)
    {
        lock (Locker)
        {
            if (_uniqueInstance == null)
            {
                _uniqueInstance = new LockSingleton();
            }
        }
    }
    return _uniqueInstance;
}

3.使用lock

Task.Run(() =>
{
    LockSingleton lockSingleton = LockSingleton.GetInstance();
    Console.WriteLine(lockSingleton.GetHashCode());

});

Task.Run(() =>
{
    LockSingleton lockSingleton = LockSingleton.GetInstance();
    Console.WriteLine(lockSingleton.GetHashCode());
});

输出结果

over!
6044116
6044116

延迟加载(Lazy)

public class LazySingleton
{
    private static readonly Lazy<LazySingleton> SingletonLazy = new Lazy<LazySingleton>(() => new LazySingleton());

    /// <summary>
    /// 私有构造函数
    /// </summary>
    private LazySingleton()
    {
        Console.WriteLine("我被创建了.Lazy");
    }

    /// <summary>
    /// 获取实例
    /// </summary>
    /// <returns></returns>
    public static LazySingleton GetInstance()
    {
        return SingletonLazy.Value;
    }
}

总结

单例主要分为如下几种方式,在实际使用过程中:建议采用延迟加载(Lazy)

饿汉式 懒汉式 懒汉式+lock锁+双重判断 延迟加载(Lazy)
线程安全 线程不安全 线程安全 线程安全
不是延迟加载(会浪费内存) 会延迟加载 会延迟加载 会延迟加载
没有加锁 没有加锁 加锁 加锁

 

转载请注明:XAMPP中文组官网 » 创建型-单例模式 SingletonPattern

您必须 登录 才能发表评论!