Singleton单例模式最佳实践

单例模式最佳实践

2. 核心作用：

• – 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

常见应用场景： – Windows的Task Manager（任务管理器）就是很典型的单例模式

– windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

– 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。

– 网站的计数器，一般也是采用单例模式实现，否则难以同步。

– 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作

，否则内容不好追加。

– 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

– 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

– Application 也是单例的典型应用（Servlet编程中会涉及到）

– 在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理

– 在servlet编程中，每个Servlet也是单例

– 在spring MVC框架/struts1框架中，控制器对象也是单例

3. 单例模式的优点：

– 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要

比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动

时直接产生一个单例对象，然后永久驻留内存的方式来解决

– 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计

一个单例类，负责所有数据表的映射处理

• 常见的五种单例模式实现方式：

– 主要：

• 饿汉式（线程安全，调用效率高。 但是，不能延时加载。）

• 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）

– 其他：

• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）

• 静态内部类式(线程安全，调用效率高。 但是，可以延时加载)

• 枚举单例(线程安全，调用效率高，不能延时加载)
饿汉式实现很简单，在静态构造函数中立即进行实例化：

public class Singleton
{
    private static readonly Singleton _instance;
    static Singleton()
    {
        _instance = new Singleton();
    }

    public static Singleton Instance
    {
        get
        {
            return _instance;
        }
    }
}

注意，为了确保单例性，需要使用 readonly 关键字声明实例不能被修改。

以上写法可简写为：

public class Singleton
{
    private static readonly Singleton _instance = new Singleton();
    public static Singleton Instance
    {
        get
        {
            return _instance;
        }
    }
}

这里的 new Singleton() 等同于在静态构造函数中实例化。在 C# 7 中还可以进一步简写如下：

public class Singleton
{
    public static Singleton Instance { get; } = new Singleton();
}

一句代码就搞定了，此写法，实例化也是在默认的静态构造函数中进行的。如果是饿汉式需求，这种实现是最简单的。有人会问这会不会有线程安全问题，如果多个线程同时调用 Singleton.Instance 会不会实例化了多个实例。不会，因为 CLR 确保了所有静态构造函数都是线程安全的。

懒汉式
懒汉式单例实现需要考虑线程安全问题，先来看一段经典的线程安全的单列模式实现代码：

 private static volatile DispatcherManager dispatcherManager;
    private static readonly object locker = new object();
    public static DispatcherManager GetInstance()
    {
        if (null == dispatcherManager)
        {
            lock (locker)
            {
                if (null == dispatcherManager)
                {
                    dispatcherManager = new DispatcherManager();
                }
            }
        }
        return dispatcherManager;
    }

 private static readonly Lazy<DispatcherManager> _instance = 
 new Lazy<DispatcherManager>(() => new DispatcherManager());

        public static DispatcherManager Instance
        {
            get { return _instance.Value; }
        }

public class Program
{
    public static void Main()
    {
        var instance = LazySingleton.Instance;
    }
}

使用 Lazy 可以使对象的实例化延迟到第一次被调用的时候执行，通过访问它的 Value 属性来创建并获取实例，并且读取一个 Lazy 实例的 Value 属性只会执行一次实例化代码，确保了线程安全。