c# - 具有单一实例化的全局线程安全多值自定义字典

Question

我想要一个类似于在不同线程之间共享的多值字典的全局对象。

我希望对象只创建一次(例如从数据库获取数据)，然后由不同的线程使用。

对象应该可以很容易地通过附加属性进行扩展(目前只有 JobName 和 URL)。

如果可能的话，我宁愿避免锁定。

我面临以下问题:

• 下面显示的当前版本不是线程安全的；
• 我不能使用 ConcurrentDictionary，因为我扩展了 Dictionary 对象以允许每个键有多个值；

这是应该很容易修改的对象结构:

    public struct JobData
    {
        public string JobName;
        public string URL;
    }

我扩展了 Dictionary 对象以允许每个键有多个值:

    public class JobsDictionary : Dictionary<string, JobData>
    {
        public void Add(string key, string jobName, string url)
        {
            JobData data;
            data.JobName = jobName;
            data.URL = url;
            this.Add(key, data);
        }
    }

线程间共享的静态类。如您所见，它会在第一次为特定作业调用它时为该作业创建一个字典条目。

例如，第一次调用“收入”时，它将创建“收入”字典条目。这会产生线程安全问题:

public static class GlobalVar
{
    private static JobsDictionary jobsDictionary = new JobsDictionary();
    public static JobData Job(string jobCat)
    {   
        if (jobsDictionary.ContainsKey(jobCat))
            return jobsDictionary[jobCat];
        else
        {
            String jobName;
            String url = null;

            //TODO: get the Data from the Database
            switch (jobCat)
            {
                case "earnings":
                    jobName="EarningsWhispers";
                    url = "http://www.earningswhispers.com/stocks.asp?symbol={0}";
                    break;
                case "stock":
                    jobName="YahooStock";
                    url = "http://finance.yahoo.com/q?s={0}";
                    break;
                case "functions":
                    jobName = "Functions";
                    url = null;
                    break;
                default:
                    jobName = null;
                    url = null;
                    break;
            }
            jobsDictionary.Add(jobCat, jobName, url);
            return jobsDictionary[jobCat];
        }
    }

在每个 Thread 中，我以这种方式获取特定的 Job 属性:

//Get the Name
string JobName= GlobalVar.Job(jobName).JobName;

//Get the URL
string URL = string.Format((GlobalVar.Job(jobName).URL), sym);

如何创建一个“实例化”一次的自定义字典(我知道这不是正确的术语，因为它是静态的......)并且它是线程安全的？

谢谢

更新

好的，这是新版本。

我通过删除 switch 语句并一次加载所有字典项来简化代码(无论如何我都需要它们)。

这种方案的优点是只加一次锁:在添加字典数据时(第一个进入锁的Thread会向字典添加数据)。当Threads访问字典进行读取时，字典没有被锁定。

它应该是线程安全的，并且不应导致死锁，因为 jobsDictionary 是私有(private)的。

public static class GlobalVar
{
    private static JobsDictionary jobsDictionary = new JobsDictionary();   
    public static JobData Job(string jobCat)
    {
        JobData result;
        if (jobsDictionary.TryGetValue(jobCat, out result))
            return result;

        //if the jobsDictionary is not initialized yet...
        lock (jobsDictionary)
        {
            if (jobsDictionary.Count == 0)
            {
                //TODO: get the Data from the Database
                jobsDictionary.Add("earnings", "EarningsWhispers", "http://www.earningswhispers.com/stocks.asp?symbol={0}");
                jobsDictionary.Add("stock", "YahooStock", "http://finance.yahoo.com/q?s={0}");   
                jobsDictionary.Add("functions", "Functions", null);  
            }
            return jobsDictionary[jobCat];
        }
    }
}

Answer 1

如果只填充集合一次，则根本不需要任何锁定，因为字典在仅从中读取时是线程安全的。如果你想防止多个线程多次初始化，你可以在初始化期间使用双重检查锁，如下所示:

static readonly object syncRoot = new object();
static Dictionary<string, JobData> cache;

static void Initialize()
{
    if (cache == null)
    {
        lock (syncRoot)
        {
            if (cache == null)
            {
                cache = LoadFromDatabase();
            }
        }
    }
}

与其让每个线程都访问字典，不如将其隐藏在仅公开您真正需要的操作的外观之后。这使得线程安全的推理变得容易得多。例如:

public class JobDataCache : IJobData
{
    readonly object syncRoot = new object();
    Dictionary<string, JobData> cache;

    public void AddJob(string key, JobData data)
    {
        lock (this.syncRoot)
        {
            cache[key] = data;
        }
    }
}

在没有衡量锁定实际上对性能有太大影响的情况下试图阻止锁定是不好的。防止这样做。经常使用简单的 lock语句比编写无锁代码简单得多。与普通的软件错误相比，并发错误存在一个严重的问题。它们很难复制，也很难追踪。如果可以，请避免编写并发错误。您可以通过编写最简单的代码来做到这一点，即使速度较慢。如果证明速度太慢，您可以随时进行优化。

如果你想编写无锁代码，请尝试使用不可变数据结构，或防止更改现有数据。这是我在编写 Simple Injector 时使用的一个技巧(一个可重用的库)。在这个框架中，我从不更新内部字典，而是总是用新的完全替换它。因此字典本身永远不会改变，对该实例的引用只是被一个全新的字典所取代。这使您不必完全进行锁定。但是，您必须意识到可能会丢失更新。换句话说，当多个线程更新该字典时，一个人可以松开它的更改，因为每个线程都会创建该字典的一个新副本，并将自己的值添加到自己的副本中，然后再将该引用公开给其他线程。

换句话说，您只能在外部调用者只读取时使用此方法(并且您可以从丢失的更改中恢复，例如通过再次查询数据库)。

更新

由于我在@ili 的回答中解释的原因，您的更新版本仍然不是线程安全的。以下将达到目的:

public static class GlobalVar
{
    private static readonly object syncRoot = new object();
    private static JobsDictionary jobsDictionary = null;

    public static JobData Job(string jobCat)
    {
        Initialize();

        return jobsDictionary[jobCat];
    }

    private void Initialize()
    {
        // Double-checked lock.
        if (jobsDictionary == null)
        {
            lock (syncRoot)
            {
                if (jobsDictionary == null)
                {
                    jobsDictionary = CreateJobsDictionary();
                }
            }
        }
    }

    private static JobsDictionary CreateJobsDictionary()
    {
        var jobs = new JobsDictionary();

        //TODO: get the Data from the Database
        jobs.Add("earnings", "EarningsWhispers", "http://...");
        jobs.Add("stock", "YahooStock", "http://...");
        jobs.Add("functions", "Functions", null);

        return jobs;
    }
}

您还可以使用静态构造函数，这样您就不必自己编写双重检查锁。但是，在静态构造函数中调用数据库是很危险的，因为静态构造函数只会运行一次，当它失败时，只要 AppDomain 存在，完整的类型就无法使用。换句话说，发生这种情况时必须重新启动您的应用程序。

更新 2:

您还可以使用 .NET 4.0 的 Lazy<T> ，这比双重检查锁更安全，因为它更容易实现(也更容易正确实现)并且在内存模型较弱(比 x86 更弱，例如 ARM)的处理器架构上也是线程安全的:

static Lazy<Dictionary<string, JobData>> cache =
    new Lazy<Dictionary<string, JobData>>(() => LoadFromDatabase());