我必须采取哪些选项才能使此代码线程安全？

Question

我有这段代码，为简洁起见，跳过了很多内容，但场景是这样的：

 public class Billing
    {
        private List<PrecalculateValue> Values = new List<PrecalculateValue>();

        public int GetValue(DateTime date)
        {
            var preCalculated = Values.SingleOrDefault(g => g.date == date).value;
            //if exist in Values, return it
            if(preCalculated != null)
            {
               return preCalculated;
            }

            // if it does not exist calculate it and store it in Values
            int value = GetValueFor(date);
            Values.Add(new PrecalculateValue{date = date, value = value});

            return value;
        }

        private object GetValueFor(DateTime date)
        {
            //some logic here
        }
    }

我有一个 List; Values 其中我存储了我已经计算出的所有值以供以后使用，我这样做主要是因为我不想为同一客户端重新计算两次，每次计算都涉及大量操作并需要 500 到 1000 之间ms，并且由于孔计费类中涉及一些递归，因此很有可能重用该值。

所有这些工作都完美，直到我做了一个测试，我为两个不同的客户端同时进行了两个计算，并且 Values.Single(g => g.date == date).value 行返回了一个异常，因为它在集合中发现了多个结果。 所以我检查了列表，它将两个客户端的值存储在同一个列表中。我该怎么做才能避免这个小问题呢？

Answer 1

好吧，首先，这一行：

return Values.Single(g => g.date == date).value;

使得后续的行永远不会被调用。我猜你已经在这里解释了一下你的代码？

如果您想要同步对 Values 列表的写入，最直接的方法是在您要修改列表的代码中的所有位置锁定公共对象：

int value = GetValueFor(date);

lock (dedicatedLockObject) {
    Values.Add(new PrecalculateValue{date = date, value = value});
}

return value;

但是还有其他值得注意的事情：由于您似乎希望每个 DateTime 有一个 PrecalculateValue，因此更合适的数据结构可能是 Dictionary; - 它将根据您的 DateTime 键提供闪电般的 O(1) 查找，而 List

则需要迭代以找到您要查找的内容。

完成此更改后，您的代码可能如下所示：

public class Billing
{
    private Dictionary<DateTime, PrecalculateValue> Values = 
        new Dictionary<DateTime, PrecalculateValue>();

    private readonly commonLockObject = new object();

    public int GetValue(DateTime date)
    {
        PrecalculateValue cachedCalculation;

        // Note: for true thread safety, you need to lock reads as well as
        // writes, to ensure that a write happening concurrently with a read
        // does not corrupt state.
        lock (commonLockObject) {
            if (Values.TryGetValue(date, out cachedCalculation))
                return cachedCalculation.value;
        }

        int value = GetValueFor(date);

        // Here we need to check if the key exists again, just in case another
        // thread added an item since we last checked.
        // Also be sure to lock ANYWHERE ELSE you're manipulating
        // or reading from the collection.
        lock (commonLockObject) {
            if (!Values.ContainsKey(date))
                Values[date] = new PrecalculateValue{date = date, value = value};
        }

        return value;
    }

    private object GetValueFor(DateTime date)
    {
        //some logic here
    }
}

最后一条建议：除非集合中不存在超过一个特定值这一点至关重要，否则 Single 方法就太过分了。如果您只想获取第一个值并忽略潜在的重复项，则 First 既更安全（例如，发生异常的可能性更小）又更快（因为它不必遍历整个值）收藏）。

Answer 2

可以使用类似的东西

public int GetValue(DateTime date)
{

    var result = Values.Single(g => g.date == date) ?? GetValueFor(date);

    lock (Values)
    {
        if (!Values.Contains(result)) Values.Add(result);
    }
    return result.value;
}

private PrecalculateValue GetValueFor(DateTime date)
{
    //logic
    return new PrecalculateValue() ;
}

，但建议使用字典来获取键值对列表。