Question

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

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

我不断遍历所有市场，分批请求数据，每个线程一批，3个线程。

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

我使用以下代码：

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和lock）。

所以出于某种原因我的锁不起作用？我觉得它显而易见，但我很想念它。

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

由于

Answer 1

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

Answer 2

在我看来，你应该使用Queue＆lt;＆gt;创建一个就业渠道。

像这样的东西

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

C＃ - 锁定不工作但挥发性和锁定有效吗？

2 个答案: