C# - 锁不起作用但易失性和锁可以吗？

Question

我正在尝试尽可能快速高效地轮询 API 以获取市场数据。 API 允许您根据请求从 batchSize 市场获取市场数据。 API 允许您有 3 个并发请求，但不能有更多（或引发错误）。

我可能会请求来自多个不同市场的batchSize 数据。

我不断循环遍历所有的市场，分批请求数据，每个线程一个批次，任何时候三个线程。

市场的总数（以及批次）可以随时变化。

我正在使用以下代码：

private static object lockObj = new object();

private void PollMarkets()
{
    const int NumberOfConcurrentRequests = 3;

    for (int i = 0; i < NumberOfConcurrentRequests; i++)
    {
        int batch = 0;
        Task.Factory.StartNew(async () =>
        {    
            while (true)
            {
                if (markets.Count > 0)
                {
                    List<string> batchMarketIds;

                    lock (lockObj)
                    {
                        var numBatches = (int)Math.Ceiling((double)markets.Count / batchSize);
                        batchMarketIds = markets.Keys.Skip(batch*batchSize).Take(batchSize).ToList();
                        batch = (batch + 1) % numBatches;
                    }

                    var marketData = await GetMarketData(batchMarketIds);

                    // Do something with marketData

                    }
                    else
                    {
                        await Task.Delay(1000); // wait for some markets to be added.
                    }
                }
            }
       });
    }
}

即使在临界区有锁，每个线程都以 batch = 0 开始（每个线程经常轮询重复数据）。

如果我将批处理更改为私有 volatile 字段，则上述代码将按我的意愿工作（易失性和锁定）。

所以由于某种原因我的锁不起作用？我觉得这很明显，但我错过了。

我认为这里最好使用锁而不是 volatile 字段，这也正确吗？

谢谢

Answer 1

问题在于您在 for 循环中定义批处理变量。这意味着线程使用自己的变量而不是共享它。

Answer 2

在我看来，您应该使用 Queue 来创建作业管道。

类似的东西

private int batchSize = 10;
private Queue<int> queue = new Queue<int>();

private void AddMarket(params int[] marketIDs)
{
    lock (queue)
    {
        foreach (var marketID in marketIDs)
        {
            queue.Enqueue(marketID);
        }

        if (queue.Count >= batchSize)
        {
            Monitor.Pulse(queue);
        }
    }
}

private void Start()
{
    for (var tid = 0; tid < 3; tid++)
    {
        Task.Run(async () =>
        {
            while (true)
            {
                List<int> toProcess;

                lock (queue)
                {
                    if (queue.Count < batchSize)
                    {
                        Monitor.Wait(queue);
                        continue;
                    }

                    toProcess = new List<int>(batchSize);
                    for (var count = 0; count < batchSize; count++)
                    {
                        toProcess.Add(queue.Dequeue());
                    }

                    if (queue.Count >= batchSize)
                    {
                        Monitor.Pulse(queue);
                    }
                }

                var marketData = await GetMarketData(toProcess);
            }
        });
    }
}