如何在 C# 中包含对象列表的字典上使用锁？

Question

我有以下课程：

public static class HotspotsCache
{
  private static Dictionary<short, List<HotSpot>> _companyHotspots = new Dictionary<int, List<HotSpot>>();
  private static object Lock = new object();


  public static List<HotSpot> GetCompanyHotspots(short companyId)
  {
     lock (Lock)
     {
       if (!_companyHotspots.ContainsKey(companyId))
       {
         RefreshCompanyHotspotCache(companyId);
       }

       return _companyHotspots[companyId];
     }
  }

  private static void RefreshCompanyHotspotCache(short companyId)
  {
    ....

    hotspots = ServiceProvider.Instance.GetService<HotspotsService>().GetHotSpots(..);
    _companyHotspots.Add(companyId, hotspots);

   ....
  }

我遇到的问题是在 RefreshCompanyHotspotCache 方法中获取热点的操作需要花费大量时间。因此，当一个线程正在对某个 CompanyId 执行缓存刷新时，所有其他线程都会等待该操作完成，尽管可能有线程正在请求另一个 companyId 的热点列表，而该列表已加载到该 CompanyId 中。字典。我希望最后这些线程不被锁定。我还希望请求尚未加载到缓存中的公司的热点列表的所有线程都等待，直到列表完全检索并加载到字典中。

有没有办法只锁定正在读取/写入特定 companyId（正在刷新）的缓存的线程，并让正在请求另一家公司数据的其他线程完成其工作？

我的想法是使用锁数组

lock (companyLocks[companyId])
{
...
}

但这并没有解决任何问题。与一家公司打交道的线程仍在等待为其他公司刷新缓存的线程。

Answer 1

使用 Snowbear 也提到的双重检查锁定机制 - 这将防止您的代码在实际上不需要时锁定。

根据您为每个客户端分配一个锁的想法，我过去使用过这种机制，尽管我使用了锁字典。我制作了一个实用程序类，用于从钥匙获取锁定对象：

/// <summary>
/// Provides a mechanism to lock based on a data item being retrieved
/// </summary>
/// <typeparam name="T">Type of the data being used as a key</typeparam>
public class LockProvider<T> 
{
    private object _syncRoot = new object();
    private Dictionary<T, object> _lstLocks = new Dictionary<T, object>();

    /// <summary>
    /// Gets an object suitable for locking the specified data item
    /// </summary>
    /// <param name="key">The data key</param>
    /// <returns></returns>
    public object GetLock(T key)
    {
        if (!_lstLocks.ContainsKey(key))
        {
            lock (_syncRoot)
            {
                if (!_lstLocks.ContainsKey(key))
                    _lstLocks.Add(key, new object());
            }
        }
        return _lstLocks[key];
    }
}

所以只需按以下方式使用它......

private static LockProvider<short> _clientLocks = new LockProvider<short>();
private static Dictionary<short, List<HotSpot>> _companyHotspots = new Dictionary<short, List<HotSpot>>();

  public static List<HotSpot> GetCompanyHotspots(short companyId)
  {
      if (!_companyHotspots.ContainsKey(companyId)) 
      {
          lock (_clientLocks.GetLock(companyId)) 
          {
              if (!_companyHotspots.ContainsKey(companyId))
              {
                   // Add item to _companyHotspots here...
              }
      }
      return _companyHotspots[companyId];
  }

Answer 2

您只锁定 1 个线程并让其更新，而其他人都使用旧列表怎么样？

private static Dictionary<short, List<HotSpot>> _companyHotspots = new Dictionary<short, List<HotSpot>>();
private static Dictionary<short, List<HotSpot>> _companyHotspotsOld = new Dictionary<short, List<HotSpot>>();
private static bool _hotspotsUpdating = false;
private static object Lock = new object();

public static List<HotSpot> GetCompanyHotspots(short companyId)
{
    if (!_hotspotsUpdating)
    {
        if (!_companyHotspots.ContainsKey(companyId))
        {
            lock (Lock)
            {
                _hotspotsUpdating = true;
                _companyHotspotsOld = _companyHotspots;
                RefreshCompanyHotspotCache(companyId);

                _hotspotsUpdating = false;
                return _companyHotspots[companyId];
            }
        }
        else
        {
            return _companyHotspots[companyId];
        }
    }
    else
    {
        return _companyHotspotsOld[companyId];
    }
}

Answer 3

您研究过 ReaderWriterLockSlim 吗？这应该能够让您获得更细粒度的锁定，只在需要时才采用写锁。

您可能需要注意的另一件事是虚假共享。我不知道锁是如何准确实现的，但是如果您锁定数组中的对象，它们在内存中必然彼此靠近，可能会将它们放在同一个缓存行上，因此锁可能不会按照您的预期运行。

另一个想法是，如果您将最后一个代码片段更改为

object l = companyLocks[companyId];
lock(l){

}

锁语句，那么会发生什么，这可能比预期的更多。

国杰

Answer 4

新想法，仅在创建列表时锁定列表。

如果你能保证每个公司至少有一个热点，那么可以这样做：

public static class HotspotsCache
{
    private static Dictionary<short, List<HotSpot>> _companyHotspots = new Dictionary<int, List<HotSpot>>();

    static HotspotsCache()
    {
        foreach(short companyId in allCompanies)
        {
            companyHotspots.Add(companyId, new List<HotSpot>());
        }
    }

    public static List<HotSpot> GetCompanyHotspots(short companyId)
    {
        List<HotSpots> result = _companyHotspots[companyId];

        if(result.Count == 0)
        {
            lock(result)
            {
                if(result.Count == 0)
                {
                    RefreshCompanyHotspotCache(companyId, result);
                }
            }
        }

        return result;
    }

    private static void RefreshCompanyHotspotCache(short companyId, List<HotSpot> resultList)
    {
        ....

        hotspots = ServiceProvider.Instance.GetService<HotspotsService>().GetHotSpots(..);
        resultList.AddRange(hotspots);

        ....
    }
}

由于字典在初始创建后正在修改，因此不需要对其进行任何锁定。我们只需要在填充各个列表时锁定它们，读取操作不需要锁定（包括初始 Count == 0）。

Answer 5

如果您能够使用 .NET 4，那么答案很简单 - 使用 ConcurrentDictionary相反，让它为您处理并发详细信息：

public static class HotSpotsCache
{
    private static readonly ConcurrentDictionary<short, List<HotSpot>>
        _hotSpotsMap = new ConcurrentDictionary<short, List<HotSpot>>();

    public static List<HotSpot> GetCompanyHotSpots(short companyId)
    {
        return _hotSpotsMap.GetOrAdd(companyId, id => LoadHotSpots(id));
    }

    private static List<HotSpot> LoadHotSpots(short companyId)
    {
        return ServiceProvider.Instance
                              .GetService<HotSpotsService>()
                              .GetHotSpots(/* ... */);
    }
}

如果您无法使用 .NET 4，那么您使用多个更细粒度的锁的想法是一个好的：

public static class HotSpotsCache
{
    private static readonly Dictionary<short, List<HotSpot>>
        _hotSpotsMap = new Dictionary<short, List<HotSpot>();

    private static readonly object _bigLock = new object();
    private static readonly Dictionary<short, object>
        _miniLocks = new Dictionary<short, object>();

    public static List<HotSpot> GetCompanyHotSpots(short companyId)
    {
        List<HotSpot> hotSpots;
        object miniLock;
        lock (_bigLock)
        {
            if (_hotSpotsMap.TryGetValue(companyId, out hotSpots))
                return hotSpots;

            if (!_miniLocks.TryGetValue(companyId, out miniLock))
            {
                miniLock = new object();
                _miniLocks.Add(companyId, miniLock);
            }
        }
        lock (miniLock)
        {
            if (!_hotSpotsMap.TryGetValue(companyId, out hotSpots))
            {
                hotSpots = LoadHotSpots(companyId);
                lock (_bigLock)
                {
                    _hotSpotsMap.Add(companyId, hotSpots);
                    _miniLocks.Remove(companyId);
                }
            }
            return hotSpots;
        }
    }

    private static List<HotSpot> LoadHotSpots(short companyId)
    {
        return ServiceProvider.Instance
                              .GetService<HotSpotsService>()
                              .GetHotSpots(/* ... */);
    }
}