3

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

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

该对象应该可以通过其他属性轻松扩展（目前只有 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);
        }
    }

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

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

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];
        }
    }

在每个线程中，我以这种方式获取特定的 Job 属性：

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

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

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

谢谢

更新

好的，这是新版本。

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

这种方案的好处是只加锁一次：当字典数据被添加时（第一个进入锁的线程将数据添加到字典中）。当线程访问字典进行阅读时，它没有被锁定。

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

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];
        }
    }
}
4

2 回答 2

6

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

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());
于 2012-04-06T09:59:17.833 回答
-1

1）使用单例模式来拥有一个实例（其中一种方法是static像你一样使用类）

2）为了使任何线程安全，你应该使用lock它或者它是模拟的。如果您害怕不必要的锁，请这样做：

public object GetValue(object key)
{
    object result;
    if(_dictionary.TryGetValue(key, out result) 
        return result;

     lock(_dictionary)
     {
        if(_dictionary.TryGetValue(key, out result) 
            return result;
        //some get data code
        _dictionary[key]=result;
        return result;
     }
}
于 2012-04-06T10:18:36.277 回答