更快的KV vs字典与并发词典，仅在更新字典的值时才使用该字典

Question

流股票的直播价格，每张股票都是关键（INT），其价值类型为struct（不是类） 字典＆lt; int，tick＆gt;。该字典用所有键初始化一次，并从WebSocket回调中随机更新（无新添加）值。从另一个线程中，该字典每20毫秒就不断迭代以获取最新值。字典的大小为5000键。因此，字典不是线程安全的，contrentDictionary的性能很少。那么，更快的KV速度更好吗？

如果我们不添加新值，只是从一个线程更新现有的键值并从另一个线程读取现有的键值，是否会安全？ 在下面的代码块中，“点A”和“点B”将具有相同的值？

 /// <summary>
/// this struct from 3rdpary library
/// </summary>
public struct Tick
{
    public DateTime DateTime { get; set; }
    public uint InstrumentToken { get; set; }
    public decimal LastPrice { get; set; }
}

class TickDataProcessor
{
    private Dictionary<UInt32, Tick> AllStocksTickData { get; set; }
    private Dictionary<UInt32, Tick> AllPreviousStocksTickData { get; set; }


    private void Initialize()
    {
        AllPreviousStocksTickData = new Dictionary<uint, Tick>(capacity: 5000);
        AllPreviousStocksTickData = new Dictionary<uint, Tick>(capacity: 5000);

        // initialize dict with all empty values, after this no more additions
        UInt32 key = 1000001;
        for (int i = 0; i < 5000; i++)
        {
            AllStocksTickData[key] = new Tick();
            AllPreviousStocksTickData[key] = new Tick();
            key++;
        }
    }

    /// <summary>
    ///real time streaming of stock data from stock broker
    /// this method is call back of websocket, websocket callback comes every millisecond for random key
    /// it will update the value of that key.
    /// </summary>
    /// <param name="tickData"></param>
    public void OnNewTickData(Tick tickData)
    {
        AllStocksTickData[tickData.InstrumentToken] = tickData;
    }

    public void Start()
    {
        var ts = new ThreadStart(OneBackgroundMethodStockPriceAnalyzer);
        var backgroundThread = new Thread(ts);
        backgroundThread.Start();

        var ts2 = new ThreadStart(TwoBackgroundMethodStockPriceAnalyzer);
        var backgroundThread2 = new Thread(ts2);
        backgroundThread2.Start();
    }

    private void TwoBackgroundMethodStockPriceAnalyzer()
    {
        while (true)
        {
            foreach (var entry in AllStocksTickData)
            {
                // second thread
            }
        }
    }

  private  void OneBackgroundMethodStockPriceAnalyzer()
    {
        while (true)
        {
            foreach (var entry in AllStocksTickData)
            {
                var key = entry.Key;
                var tickData = entry.Value; // Point A
                /*
                 * process tickdata
                 *
                 */
                if (AllPreviousStocksTickData[key].LastPrice >= tickData.LastPrice)
                {
                    // calculate % of change
                    // other calculations...
                }

                AllPreviousStocksTickData[key] = entry.Value; // Point B
            }
            Thread.Sleep(20);
        }
    }
}

class Program

{
    public static void Main(string[] args)
    {
        var tickDataProcessor = new TickDataProcessor();
        tickDataProcessor.Start();
        Console.ReadLine();
    }
}

仅考虑高性能的字典值时，要使用哪一个。

更快的kv Quick-start start指南

Answer 1

如果我们不添加新值，只需从一个线程更新现有的键值，然后从另一个线程读取现有的键值，则通常是安全的吗？

我将仅解决这个问题的这一部分。不，在多线程环境中使用普通字典＆lt; int，十进制＆gt;，其中固定键的数量并可以更新值，绝对不是线程安全。这是因为更新十进制不是原子操作，因此可以撕裂十进制值。您可以在此处找到有关此现象的实验证明：在C＃中。