C# - 周期性数据读取和 Thread.Sleep()

Question

我的 C# 应用程序从特殊的 USB 设备读取数据。数据被读取为所谓的“消息”，每个消息都有 24 个字节。每秒必须读取的消息量可能不同（最大频率相当高，大约每秒 700 条消息），但应用程序必须全部读取。

读取消息的唯一方法是调用函数“ReadMessage”，该函数返回从设备读取的一条消息。该函数来自外部 DLL，我无法修改它。

我的解决方案：我有一个单独的线程，它在程序运行期间一直在运行，唯一的工作就是循环读取消息。然后在主应用程序线程中处理接收到的消息。

“读取线程”中执行的函数如下：

private void ReadingThreadFunction() {
    int cycleCount;
    try {
        while (this.keepReceivingMessages) {
            cycleCount++;
            TRxMsg receivedMessage;
            ReadMessage(devHandle, out receivedMessage);

            //...do something with the message...
        }
    }
    catch {
        //... catch exception if reading failed...
    }
}

此解决方案运行良好，所有消息均已正确接收。但是，应用程序消耗太多资源，我的电脑的 CPU 运行在 80% 以上。因此我想减少它。

感谢“cycleCount”变量，我知道线程的“循环速度”约为每秒 40 000 个循环。这是不必要的太多，因为我需要接收最多 700 条消息/秒。 （并且设备有大约 100 条消息的缓冲区，因此循环速度可以更低一些）

我试图通过 Thread.Sleep(1) 将线程挂起 1 毫秒来降低循环速度；命令。当然，这不起作用，循环速度变成了大约 70 循环/秒，这不足以读取所有消息。我知道这种尝试很愚蠢，让线程进入睡眠状态然后唤醒他需要的时间远超过 1 毫秒。

但是，我不知道还能做什么：除了 Thread.Sleep 之外，还有其他方法可以减慢线程执行速度（以减少 CPU 消耗）吗？还是我完全错了，我应该为这个任务使用不同的东西而不是 Thread，也许是 Threading.Timer 或 ThreadPool？

非常感谢您提出的所有建议。这是我在这里的第一个问题，我是使用线程的初学者，所以如果不够清楚，请原谅。

Answer 1

使用高精度的计时器。您应该尝试使用多媒体计时器。它将帮助您减少 CPU 使用率。我不确定解决办法，但是对于一个恒定的时间（你不不断改变时间间隔，它是相当准确的）。您可以保持 10 毫秒的分辨率，并且对于计时器的每次调用，您可以读取整个缓冲区，直到它为空或说 100 次。这应该会有所帮助。

Answer 2

我建议使用分析器，或者使用 VS2010 中的分析器。你需要找出瓶颈，而不是随意改变一些东西来看看它是否会突然起作用。

Answer 3

如果没有消息，ReadMessage 会返回什么？

只有当它告诉你没有消息时，你才应该让线程休眠。在这种情况下只睡 1 毫秒就可以了。

Answer 4

使用超时为 1 毫秒的 AutoResetEvent 怎么样？

private void ReadingThreadFunction() {

    try {
            var autoReset = new AutoResetEvent(false);
            autoReset.WaitOne(1);
            TRxMsg receivedMessage;
            ReadMessage(devHandle, out receivedMessage);

            //...do something with the message...
        }
    }
    catch {
        //... catch exception if reading failed...
    }
}

编辑：一定要检查消息是否可用，就像其他答案所建议的那样......

Answer 5

1. 确认您完全理解您的 DLL 公开的 API。有什么方法可以使用库来通知您有新消息的到来？如果您描述的库中没有内置信号或通知，我会感到惊讶。

2. 如果您必须轮询，那么当您检查消息时，检索所有 条消息。不要只是取回一个然后再去睡觉。获取所有消息，直到没有更多消息可获取，因为您想缓冲以清除。

Answer 6

我认为你应该做的是使用带计时器的单例类。这个类的作用是每秒给你 700 条消息，如果需要更多，它每秒等待并重试 700 条消息。您可以在另一个线程上实例化它。单例是线程安全的。

// Queue Start
ProcessQueue.Instance.Start();

// Queue Stop
ProcessQueue.Instance.Stop();

例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Timers;
using System.Diagnostics;

namespace Service.Queue
{
    /// <summary>
    /// Process Queue Singleton Class
    /// </summary>
    class ProcessQueue : IDisposable
    {

        private static readonly ProcessQueue _instance = new ProcessQueue();
        private bool _IsProcessing = false;
        int _maxMessages = 700;

        public bool IsProcessing
        {
            get { return _IsProcessing; }
            set { _IsProcessing = value; }
        }

        ~ProcessQueue()
        {
            Dispose(false);
        }

        public static ProcessQueue Instance
        {
            get
            {
                return _instance;
            }
        }


        /// <summary>
        /// Timer for Process Queue
        /// </summary>
        Timer timer = new Timer();

        /// <summary>
        /// Starts Process Queue
        /// </summary>
        public void Start()
        {
            timer.Elapsed += new ElapsedEventHandler(OnProcessEvent);
            timer.Interval = 1000;
            timer.Enabled = true;
        }

        /// <summary>
        /// Stops Process Queue
        /// </summary>
        public void Stop() {
            _IsProcessing = false;
            timer.Enabled = false;
        }

        /// <summary>
        /// Process Event Handler
        /// /// </summary>
        private void OnProcessEvent(object source, ElapsedEventArgs e)
        {
            if (!_IsProcessing)
            {
                _IsProcessing = true;

        for (int i = 0; i < _maxMessages; i++)
                {
            TRxMsg receivedMessage;
            ReadMessage(devHandle, out receivedMessage);
        }

                _IsProcessing = false;
            }

        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                timer.Dispose();
            }
        }

        #region IDisposable Members

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        #endregion

    }
}

Answer 7

Thread.Sleep 也意味着放弃线程的时间片。只有在再次安排之后，您才会返回到该线程。这就是您“睡眠”时间超过 1 毫秒的原因。另见this post by Peter Ritchie。

问题似乎是您必须主动轮询 DLL 以获取新消息。更好的解决方案是让 DLL 在新消息到达时通知您。但是，您说不能修改外部 DLL。

您可以尝试减少priority of the polling thread。

编辑：

例如，您可以使用DispatcherTimer 大约每毫秒触发一次。 DispatcherTimer 不会在事件尚未触发时扰乱您的 CPU。然后，您可以在处理程序中处理消息（我假设您可以判断当前是否没有消息），直到没有消息要处理。您还必须防止重入，即在事件处理程序已经运行时进入它。

作为代码示例：

// Creating the DispatcherTimer
var dispatcherTimer = new System.Windows.Threading.DispatcherTimer();
dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
dispatcherTimer.Interval = TimeSpan.FromMilliseconds(1);
dispatcherTimer.Start();


private void dispatcherTimer_Tick(object sender, EventArgs e)
{
    if (this.ProcessingEvents)
        return;

    this.ProcessingEvents = true;

    var messagesLeft = true;

    while (messagesLeft)
    {
        TRxMsg receivedMessage;
        ReadMessage(devHandle, out receivedMessage);

        // Process message
        // Set messagesLeft to false if no messages left
    }

    this.ProcessingEvents = false;
}

Answer 8

你可以试试Thread.SpinWait:

SpinWait 实质上将处理器置于一个非常紧凑的循环中，循环计数由迭代参数指定。因此，等待的持续时间取决于处理器的速度。

将此与 Sleep 方法进行对比。即使指定的时间间隔为零，调用 Sleep 的线程也会产生其当前处理器时间片的剩余部分。为 Sleep 指定一个非零间隔会从线程调度程序中删除线程，直到时间间隔结束。

SpinWait 旨在等待不产生当前时间片

它适用于您知道自己想在很短的时间内做某事的情况，因此失去时间片会过度。

Answer 9

我愿意：

//...do something with the message... 

// If the message is null, it indicates that we've read everything there is to be read.
// So lets sleep for 1ms to give the buffer chance to receive a few extra messages.
If (theMessage == null) // Buffer is empty as we failed to read a new message
{
    Thread.Sleep(1);
}

这种方式可能会给你最大的性能，而不是锤击你的 CPU。