c# - Windows 服务定期产生一个线程到最大值

Question

到目前为止，我已经阅读了数百页并使用了如此多的示例，以至于我完全感到困惑。大多数示例似乎都针对以下内容:

• 让一个计时器产生一个新线程来做一些工作，无限线程
• 生成特定数量的线程，每个线程都有一个计时器某事
• 定期做一些工作

我想要完成的是:

• 运行计时器以定期生成线程
• 此线程可能会或可能不会比计时器滴答的时间更长
• 限制可以产生的线程数
• 当线程结束时，归还线程以便再次使用
• 每个线程中的工作是相互独立的，并且可以异步运行(这并不重要)

打个比方，我希望我的应用程序像一艘有 10 条钓鱼线的渔船一样工作。一开始，你(按需)投出一个，然后投出另一个，依此类推。在任何给定时间，水中可能有 0 到 10 条钓鱼线。每当钓到鱼时，线就会被拉起并准备好再次抛出(如果有需要的话)。

听起来我应该使用线程池？我还认为为了简单起见，我应该产生一个线程，如果没有工作，立即返回它(即从某个表中选择计数，如果计数为 0，则返回线程)，而不是试图智能地找出如果我需要产卵，因为有需要。

一般情况下，系统安静的时候，会不断的产生一个线程，看到没有工作就返回，但是在繁忙的时候，线程很可能会被用到极限，系统只会继续未能生成新线程，直到一个或多个线程完成后再次返回。

我已经尝试过 System.Threading、Semaphores 和 WaitHandles，但它们都变得非常困惑。我还没有要显示的代码，因为我一直在使用不同的方法删除并重新开始。任何帮助将不胜感激。

我使用 C# 2010 进行开发。

Answer 1

在使用线程池和计时器之前，我已经得到了类似的东西:

public class MaxThreadCountWorker : IDisposable
{
    private readonly int _maxThreadCount;
    private readonly int _tickIntervalMilliseconds;
    private readonly Action _periodicWork;
    private readonly System.Threading.Timer _timer;
    private int _currentActiveCount;

    public MaxThreadCountWorker(int maxThreadCount, int tickIntervalMilliseconds, Action periodicWork)
    {
        _maxThreadCount = maxThreadCount;
        _tickIntervalMilliseconds = tickIntervalMilliseconds;
        _periodicWork = periodicWork;
        _timer = new System.Threading.Timer(_ => OnTick(), null, Timeout.Infinite, Timeout.Infinite);
        _currentActiveCount = 0;
    }

    public void Start()
    {
        _timer.Change(0, _tickIntervalMilliseconds);
    }

    public void Stop()
    {
        _timer.Change(Timeout.Infinite, Timeout.Infinite);
    }

    private void DoWork()
    {
        try
        {
            _periodicWork.Invoke();
        }
        finally
        {
            Interlocked.Decrement(ref _currentActiveCount);
        }
    }
    private void OnTick()
    {
        _timer.Change(Timeout.Infinite, Timeout.Infinite);
        try
        {
            if (_currentActiveCount >= _maxThreadCount) return;

            Interlocked.Increment(ref _currentActiveCount);
            ThreadPool.QueueUserWorkItem(_ => DoWork());
        }
        finally
        {
            _timer.Change(_tickIntervalMilliseconds, _tickIntervalMilliseconds);
        }
    }

    public void Dispose()
    {
        _timer.Dispose();
    }
} 

class Program
{
    private static object _lockObject = new object();
    private static int _runningTasks = 0;

    private static void PrintToConsole()
    {
        lock (_lockObject)
        {
            _runningTasks += 1;
        }
        try
        {
            Console.WriteLine("Starting work. Total active: {0}", _runningTasks);
            var r = new Random();
            System.Threading.Thread.Sleep(r.Next(3500));                
        } finally
        {
            lock (_lockObject)
            {
                _runningTasks -= 1;
            }                
        }
    }
    static void Main(string[] args)
    {
        using (var w = new MaxThreadCountWorker(3, 150, PrintToConsole))
        {
            w.Start();
            Console.ReadKey();
        }
    }
}