병렬 호출에서 초당 실행을 제한하십시오.

Question

TPL/Parallel.ForEach를 사용하면 단위 시간당 메소드 호출 횟수를 제한 할 수있는 기본 방법이 있습니다 (즉, 둘째). 이는 스레드 수를 제한하는 것과는 다릅니다. 아마도이 작업을 수행하기위한 간단한 해킹이있을 것입니다.

Answer 1

하나의 솔루션을 사용하여 다음 https://stackoverflow.com/a/7728872/356790

/// <summary> 
/// This class limits the number of requests (method calls, events fired, etc.) that can occur in a given unit of time. 
/// </summary> 
class RequestLimiter 
{ 

    #region Constructors 

    /// <summary> 
    /// Initializes an instance of the RequestLimiter class. 
    /// </summary> 
    /// <param name="maxRequests">The maximum number of requests that can be made in a given unit of time.</param> 
    /// <param name="timeSpan">The unit of time that the maximum number of requests is limited to.</param> 
    /// <exception cref="ArgumentException">maxRequests &lt;= 0</exception> 
    /// <exception cref="ArgumentException">timeSpan.TotalMilliseconds &lt;= 0</exception> 
    public RequestLimiter(int maxRequests , TimeSpan timeSpan) 
    { 
     // check parameters 
     if (maxRequests <= 0) 
     { 
      throw new ArgumentException("maxRequests <= 0" , "maxRequests"); 
     } 
     if (timeSpan.TotalMilliseconds <= 0) 
     { 
      throw new ArgumentException("timeSpan.TotalMilliseconds <= 0" , "timeSpan"); 
     } 

     // initialize instance vars 
     _maxRequests = maxRequests; 
     _timeSpan = timeSpan; 
     _requestTimes = new Queue<DateTime>(maxRequests); 

     // sleep for 1/10th timeSpan 
     _sleepTimeInMs = Convert.ToInt32(Math.Ceiling(timeSpan.TotalMilliseconds/10)); 
    } 

    #endregion 

    /// <summary> 
    /// Waits until an request can be made 
    /// </summary> 
    public void WaitUntilRequestCanBeMade() 
    { 
     while (!TryEnqueueRequest()) 
     { 
      Thread.Sleep(_sleepTimeInMs); 
     } 
    } 

    #region Private Members 

    private readonly Queue<DateTime> _requestTimes; 
    private readonly object _requestTimesLock = new object(); 
    private readonly int _maxRequests; 
    private readonly TimeSpan _timeSpan; 
    private readonly int _sleepTimeInMs; 

    /// <summary> 
    /// Remove requests that are older than _timeSpan 
    /// </summary> 
    private void SynchronizeQueue() 
    { 
     while ((_requestTimes.Count > 0) && (_requestTimes.Peek().Add(_timeSpan) < DateTime.Now)) 
     { 
      _requestTimes.Dequeue(); 
     } 
    } 

    /// <summary> 
    /// Attempts to enqueue a request. 
    /// </summary> 
    /// <returns> 
    /// Returns true if the request was successfully enqueued. False if not. 
    /// </returns> 
    private bool TryEnqueueRequest() 
    { 
     lock (_requestTimesLock) 
     { 
      SynchronizeQueue(); 
      if (_requestTimes.Count < _maxRequests) 
      { 
       _requestTimes.Enqueue(DateTime.Now); 
       return true; 
      } 
      return false; 
     } 
    } 

    #endregion 

} 

Answer 2

준비 표시 코드 샘플의 스레드 안전 버전을 만들기 위해 타이머입니다 :

• for .NET 4.0 TPL이 하나를 놓치지 마세요,이입니다 모든 시간과 모든 사람들의 굉장한 프로젝트! async/wait를 사용
• in C# 5.0/.NET 4.5
, WPF

코드 대하여 반응성 확장하여 샘플/예 (RX) :

• Observable.Interval Method (TimeSpan, IScheduler), MSDN 예
• Observable.Timer() sample, RxWiki

Answer 3

이 솔루션은 각 스레드의 시작 사이에 지연을 적용하고 요구 사항을 채우십시오.

private SemaphoreSlim CooldownLock = new SemaphoreSlim(1, 1); 
    private DateTime lastAction; 

    private void WaitForCooldown(TimeSpan delay) 
    { 
     CooldownLock.Wait(); 

     var waitTime = delay - (DateTime.Now - lastAction); 

     if (waitTime > TimeSpan.Zero) 
     { 
      Task.Delay(waitTime).Wait(); 
      lastAction = DateTime.Now; 
     } 

     lastAction = DateTime.Now; 

     CooldownLock.Release(); 
    } 

    public void Execute(Action[] actions, int concurrentThreadLimit, TimeSpan threadDelay) 
    { 
     if (actions.Any()) 
     { 
      Parallel.ForEach(actions, 
          new ParallelOptions() { MaxDegreeOfParallelism = concurrentThreadLimit}, 
          (currentAction) => 
          { 
           WaitForCooldown(threadDelay); 
           currentAction(); 
          }); 
     } 
    }