无队列数据时如何避免使用Thread.Sleep？Windows服务线程优化

你当前用Thread.Sleep()的实现会导致线程长时间无意义阻塞，既浪费系统资源，又没法及时响应队列中新加入的数据。下面给你几个更高效的替代方案：

1. 使用阻塞队列（推荐） #

.NET自带的BlockingCollection<T>是为生产者-消费者模式量身打造的，它的Take()方法会在队列空的时候自动让线程进入高效等待状态（不是固定时长的休眠），一旦有新数据被加入队列，线程会立即被唤醒处理，完美解决你的问题。

改造后的伪代码：

// 全局或类级别的阻塞队列，生产者往这里添加数据
private static BlockingCollection<DataItem> _queue = new BlockingCollection<DataItem>();

public static void Main()
{
    // 创建5个消费者线程
    for (int i = 0; i < 5; i++)
    {
        Thread thr = new Thread(new Consumer().DoJob);
        thr.Start();
    }
    
    // 此处可启动生产者逻辑，往_queue中添加数据
}

void DoJob()
{
    while (true)
    {
        // 队列空时自动等待，有数据立即取出
        DataItem data = _queue.Take();
        // 处理数据逻辑
        ProcessData(data);
    }
}

2. 使用等待事件（ManualResetEventSlim） #

用ManualResetEventSlim实现线程的等待与唤醒：队列空时线程等待事件信号，生产者往队列加完数据后触发事件，唤醒等待的线程。

伪代码示例：

private static Queue<DataItem> _queue = new Queue<DataItem>();
private static ManualResetEventSlim _dataAvailable = new ManualResetEventSlim(false);
private static object _lockObj = new object();

public static void Main()
{
    for (int i = 0; i < 5; i++)
    {
        Thread thr = new Thread(new Consumer().DoJob);
        thr.Start();
    }
}

void DoJob()
{
    while (true)
    {
        DataItem data = null;
        // 加锁安全取数据
        lock (_lockObj)
        {
            if (_queue.Count > 0)
            {
                data = _queue.Dequeue();
                // 取完数据后队列空了，重置事件
                if (_queue.Count == 0)
                {
                    _dataAvailable.Reset();
                }
            }
        }
        
        if (data != null)
        {
            ProcessData(data);
        }
        else
        {
            // 等待事件触发，有数据时立即唤醒
            _dataAvailable.Wait();
        }
    }
}

// 生产者添加数据的方法示例
public static void AddData(DataItem item)
{
    lock (_lockObj)
    {
        _queue.Enqueue(item);
        // 触发事件，唤醒等待的线程
        _dataAvailable.Set();
    }
}

3. 异步任务模式（现代化方案） #

如果是.NET Core/.NET 5+环境，推荐用异步任务结合Channel<T>（异步阻塞队列），无需手动管理线程，利用线程池自动调度，资源利用率更高：

private static Channel<DataItem> _channel = Channel.CreateUnbounded<DataItem>();

public static async Task Main()
{
    // 启动5个消费者异步任务
    for (int i = 0; i < 5; i++)
    {
        _ = ConsumerAsync();
    }
    
    // 生产者逻辑，异步添加数据
    // await ProducerAsync();
}

private static async Task ConsumerAsync()
{
    await foreach (var data in _channel.Reader.ReadAllAsync())
    {
        // 处理数据
        ProcessData(data);
    }
}

// 生产者方法示例
private static async Task ProducerAsync()
{
    while (true)
    {
        DataItem newData = GenerateData();
        await _channel.Writer.WriteAsync(newData);
        await Task.Delay(1000);
    }
}

这些方案都能避免线程无意义的休眠阻塞，让线程在真正有数据时才工作，空闲时处于高效等待状态，既节省资源又能及时响应数据。

内容的提问来源于stack exchange，提问作者Lelouch