根据下面给出的逻辑，我怎样才能每秒发出 50 个请求而不必再等待一秒钟？

Question

我有一个 Windows 窗体应用程序，单击按钮时，我想循环一个整数列表并以每秒只能发出 50 个并行请求的方式进行 http post 调用。这是因为目标 http 端点仅支持每秒 50 个请求。为了实现这一点，这是我的逻辑：

我已将 SemaphoreSlim 节流器声明为全局变量：

var throttler = new SemaphoreSlim(50);

在按钮单击事件中，我正在遍历项目列表并进行 http 调用：

        List<Task> lstTasks = new List<Task>();
        foreach (var item in lstItems)
        {
            lstTasks.Add(CallAsyncMtd(item));
        }

进行http调用的方法是：

private async Task CallAsyncMtd(int item, IProgress<int> progress)
{
    await throttler.WaitAsync(); // here I am doing an async wait for the semaphore so that not more than 5 threads can run at the same time

    try
    {
        await Task.Delay(1000).ConfigureAwait(false); //simulate an api call, configure await is false so the remaining code will run on separate thread            
    }
    catch (Exception e)
    {
        //do some exception handling
    }

    //saveResponseToMySQL(response) //save the http response to mysql database synchronously
    progress.Report(1); //report progress
    
    await Task.Delay(1000 * 1); //wait for 1 second
    throttler.Release(); //release semaphore
}

发出请求后，我正在等待 1 秒（在单独的线程中）。有没有更好的方法可以让我每秒发出 50 个请求，而不必按照上述逻辑再等待一秒钟？

Answer 1

在函数开始时使用秒表，而不是在结束时检查已经过去了多少时间，并且只检查Delay 所需的时间。

类似这样的：

private async Task CallAsyncMtd(int item, IProgress<int> progress)
{
    await throttler.WaitAsync(); // here I am doing an async wait for the semaphore so that not more than 5 threads can run at the same time

    var watch = new StopWatch();
    watch.Start();
    try
    {
        await ApiCall(); //simulate an api call, configure await is false so the remaining code will run on separate thread            
    }
    catch (Exception e)
    {
        //do some exception handling
    }

    //saveResponseToMySQL(response) //save the http response to mysql database synchronously
    progress.Report(1); //report progress
    watch.Stop();
    var timeToWait = Math.Max(0, 1000 - watch.Elapsed.Milliseconds);
    await Task.Delay(timeToWait); //wait for necessary amount of time
    throttler.Release(); //release semaphore
}

Answer 2

您无法将Task.delay 添加到CallAsyncMtd() 方法中，请尝试：

foreach (var item in lstItems)
{
    await Task.Delay(20);
    lstTasks.Add(CallAsyncMtd(item));
}

Answer 3

您可以链接延迟并释放信号量，但不能等待它。这会阻塞 Semaphore 额外的一秒钟，但会立即允许处理结果。

// Wait 1 second befor releasing the semaphore but do not block this request.
Task.Delay(1000 *1 ).ContinueWith(_ => throttler.Release());

如果这会导致很大的延迟，您可以将其与此答案https://stackoverflow.com/a/68998020/9271844 结合使用以减少延迟。

Answer 4

我会为此使用System.Threading.Tasks.Dataflow。使用 ActionBlock，您可以指定任务的并行度，如果有 50 个任务在执行一次调用后休眠，则每秒只有 50 个调用：

//define the ActionBlock to call CallAsyncMtd for each item
var block = new ActionBlock<int>(
    async item => { 
        await CallAsyncMtd(item, progress);
    },
    // Specify a maximum degree of parallelism.
    new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = 50
    });


//Define a BatchBlock and link it to a ActionBlock to generate Blocks of 50 items
var linkOptions = new DataflowLinkOptions { PropagateCompletion = true };


 var oneSecondBatchBlock = new BatchBlock<int>(buffSize);
 var oneSecondStatsFeedBlock = new ActionBlock<int[]>(
     async (int[] messages) => 
            {
                var watch = new Stopwatch();
                watch.Start();
                //Add to ActionBlock doing the call
                foreach (int item in messages) block.Post(item);


                watch.Stop();
                var timeToWait = Math.Max(0, 1000 - watch.Elapsed.Milliseconds);
                await Task.Delay(timeToWait);
                   
               });

 //Link Blocks
 oneSecondBatchBlock.LinkTo(oneSecondStatsFeedBlock, linkOptions);

       

        

// Add items to block
foreach (var item in lstItems)
{
     oneSecondBatchBlock.SendAsync(i).Wait();//Add Work
}
    
//wait for finish
oneSecondBatchBlock.Complete();            
await oneSecondBatchBlock.Completion;
block.Complete();
await block.Completion;

-- 编辑--

使用 BatchBlock 将工作分成 50 个部分更有意义。