CPU友好的无限循环

Question

编写无限循环很简单：

while(true){
    //add whatever break condition here
}

但这会降低 CPU 性能。该执行线程将尽可能多地消耗 CPU 的电量。

降低对 CPU 影响的最佳方法是什么？ 添加一些 Thread.Sleep(n) 应该可以解决问题，但为 Sleep() 方法设置较高的超时值可能表明应用程序对操作系统无响应。

假设我需要在控制台应用程序中每分钟左右执行一项任务。 我需要保持 Main() 在“无限循环”中运行，同时计时器将触发完成这项工作的事件。我希望保持 Main() 对 CPU 的影响最小。

您建议采用什么方法。 Sleep() 可以，但正如我已经提到的，这可能表明线程对操作系统无响应。

稍后编辑：

我想更好地解释我正在寻找的内容：

1. 我需要一个控制台应用程序而不是Windows服务。控制台应用程序可以使用 Compact Framework 模拟 Windows Mobile 6.x 系统上的 Windows 服务。

2. 我需要一种方法，让应用程序在 Windows Mobile 设备运行时保持活动状态。

3. 我们都知道，只要其静态 Main() 函数运行，控制台应用程序就会运行，因此我需要一种方法来防止 Main() 函数退出。

4. 在特殊情况下（例如：更新应用程序），我需要请求应用程序停止，因此我需要无限循环并测试某些退出条件。例如，这就是为什么 Console.ReadLine() 对我来说没有用。没有退出条件检查。

5. 关于上述内容，我仍然希望 Main() 函数尽可能资源友好。抛开检查退出条件的函数的指纹不谈。

Answer 1

为了避免无限循环，只需使用 WaitHandle 即可。要让进程从外部世界退出，请使用带有唯一字符串的 EventWaitHandle。下面是一个例子。

如果您第一次启动它，它会简单地每 10 秒打印一条消息。如果您同时启动该程序的第二个实例，它将通知其他进程正常退出并立即退出。此方法的 CPU 使用率：0%

private static void Main(string[] args)
{
    // Create a IPC wait handle with a unique identifier.
    bool createdNew;
    var waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, "CF2D4313-33DE-489D-9721-6AFF69841DEA", out createdNew);
    var signaled = false;

    // If the handle was already there, inform the other process to exit itself.
    // Afterwards we'll also die.
    if (!createdNew)
    {
        Log("Inform other process to stop.");
        waitHandle.Set();
        Log("Informer exited.");

        return;
    }

    // Start a another thread that does something every 10 seconds.
    var timer = new Timer(OnTimerElapsed, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));

    // Wait if someone tells us to die or do every five seconds something else.
    do
    {
        signaled = waitHandle.WaitOne(TimeSpan.FromSeconds(5));
        // ToDo: Something else if desired.
    } while (!signaled);

    // The above loop with an interceptor could also be replaced by an endless waiter
    //waitHandle.WaitOne();

    Log("Got signal to kill myself.");
}

private static void Log(string message)
{
    Console.WriteLine(DateTime.Now + ": " + message);
}

private static void OnTimerElapsed(object state)
{
    Log("Timer elapsed.");
}

Answer 2

您可以使用 System.Threading.Timer 类，它提供能够在给定时间段内异步执行回调。

public Timer(
    TimerCallback callback,
    Object state,
    int dueTime,
    int period
)

作为替代方案，有 System.Timers.Timer 类公开已过事件，该事件在给定时间段内引发的时间已过。

Answer 3

为什么你会容忍使用无限循环？对于这个例子，将程序设置为计划任务，每分钟运行一次，不是更经济吗？

Answer 4

为什么不编写一个小型应用程序并使用系统的任务调度程序每分钟、每小时等运行它？

另一种选择是编写一个在后台运行的 Windows 服务。该服务可以使用 MSDN 上的简单 Alarm 类，如下所示：

http://msdn.microsoft.com/en-us/library/wkzf914z%28v=VS.90%29.aspx#Y2400

您可以使用它定期触发您的方法。在内部，此 Alarm 类使用计时器：

http://msdn.microsoft .com/en-us/library/system.timers.timer.aspx

只需正确设置计时器的间隔（例如 60000 毫秒），它就会定期引发 Elapsed 事件。将事件处理程序附加到 Elapsed 事件以执行您的任务。无需仅仅为了保持应用程序的运行而实现“无限循环”。这由服务为您处理。

Answer 5

我为一个应用程序执行了此操作，该应用程序必须在文件拖放到文件夹时处理文件。最好的选择是在“main”末尾使用一个带有 Console.ReadLine() 的计时器（如建议的那样），而不放入循环。

现在，您担心告诉应用程序停止：

我也通过一些基本的“文件”监视器完成了此操作。只需在应用程序的根文件夹中创建文件“quit.txt”（通过我的程序或可能要求其停止的其他应用程序）将使应用程序退出。半代码：

<do your timer thing here>
watcher = new FileSystemWatcher();
watcher.Path = <path of your application or other known accessible path>;
watcher.Changed += new FileSystemEventHandler(OnNewFile);
Console.ReadLine();

OnNewFile 可能是这样的：

private static void OnNewFile(object source, FileSystemEventArgs e)
{
    if(System.IO.Path.GetFileName(e.FullPath)).ToLower()=="quit.txt")
        ... remove current quit.txt
        Environment.Exit(1);
}

现在您提到这是（或可能）用于移动应用程序？您可能没有文件系统观察程序。在这种情况下，也许您只需要“终止”该进程（您说“在特殊情况下（例如：更新应用程序），我需要请求该应用程序停止”。无论停止它的“请求者”是谁，都应该只需杀死该进程即可）

Answer 6

在我看来，您希望 Main() 进入可中断循环。要发生这种情况，必须在某个地方涉及多个线程（或者您的循环必须定期轮询；不过，我不在这里讨论该解决方案）。同一应用程序中的另一个线程或另一个进程中的线程必须能够向 Main() 循环发出它应该终止的信号。

如果这是真的，那么我认为您想要使用 ManualResetEvent 或 EventWaitHandle 。您可以等待该事件，直到它发出信号（并且信号必须由另一个线程完成）。

例如：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            startThreadThatSignalsTerminatorAfterSomeTime();
            Console.WriteLine("Waiting for terminator to be signalled.");
            waitForTerminatorToBeSignalled();
            Console.WriteLine("Finished waiting.");
            Console.ReadLine();
        }

        private static void waitForTerminatorToBeSignalled()
        {
            _terminator.WaitOne(); // Waits forever, but you can specify a timeout if needed.
        }

        private static void startThreadThatSignalsTerminatorAfterSomeTime()
        {
            // Instead of this thread signalling the event, a thread in a completely
            // different process could do so.

            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(5000);
                _terminator.Set();
            });
        }

        // I'm using an EventWaitHandle rather than a ManualResetEvent because that can be named and therefore
        // used by threads in a different process. For intra-process use you can use a ManualResetEvent, which 
        // uses slightly fewer resources and so may be a better choice.

        static readonly EventWaitHandle _terminator = new EventWaitHandle(false, EventResetMode.ManualReset, "MyEventName");
    }
}

Answer 7

您可以使用 Begin-/End-Invoke 来屈服于其他线程。例如，

public static void ExecuteAsyncLoop(Func<bool> loopBody)
{
    loopBody.BeginInvoke(ExecuteAsyncLoop, loopBody);
}

private static void ExecuteAsyncLoop(IAsyncResult result)
{
    var func = ((Func<bool>)result.AsyncState);
    try
    {
        if (!func.EndInvoke(result))
            return;
    }
    catch
    {
        // Do something with exception.
        return;
    }

    func.BeginInvoke(ExecuteAsyncLoop, func);
}

您可以这样使用它：

ExecuteAsyncLoop(() =>
    {
        // Do something.
        return true; // Loop indefinitely.
    });

这使用了我机器上一个核心的 60%（完全空循环）。或者，您可以在正文中使用此（源）代码循环：

private static readonly bool IsSingleCpuMachine = (Environment.ProcessorCount == 1);
[DllImport("kernel32", ExactSpelling = true)]
private static extern void SwitchToThread();

private static void StallThread()
{
    // On a single-CPU system, spinning does no good
    if (IsSingleCpuMachine) SwitchToThread();
    // Multi-CPU system might be hyper-threaded, let other thread run
    else Thread.SpinWait(1);
}

while (true)
{
    // Do something.
    StallThread();
}

在我的机器上使用了 20% 的一个核心。

Answer 8

阐述 CodeInChaos 所做的评论：

您可以设置给定的 线程的优先级。线程根据其优先级调度执行。用于确定线程执行顺序的调度算法因操作系统而异。所有线程默认为“正常”优先级，但如果您将循环设置为低；它不应该从设置为正常的线程中窃取时间。

Answer 9

Timer 方法可能是您最好的选择，但是既然您提到了 Thread.Sleep，就有一个有趣的 Thread.SpinWait 或 SpinWait struct 用于解决类似问题的替代方案，有时比短的更好Thread.Sleep 调用。

另请参阅此问题：Thread.SpinWait 方法的目的是什么？

Answer 10

这里有很多“高级”答案，但 IMO 只需使用 Thread.Sleep(lowvalue) 就足以满足大多数人的需求。

计时器也是一种解决方案，但计时器背后的代码也是一个无限循环 - 我认为 - 在经过的时间间隔内触发您的代码，但它们具有正确的无限循环设置。

如果您需要大睡眠，可以将其切成小睡眠。

因此，对于非 UI 应用程序来说，这样的解决方案是一个简单易用的 0% CPU 解决方案。

static void Main(string[] args)
{
    bool wait = true;
    int sleepLen = 1 * 60 * 1000; // 1 minute
    while (wait)
    {

        //... your code

        var sleepCount = sleepLen / 100;
        for (int i = 0; i < sleepCount; i++)
        {
            Thread.Sleep(100);
        }
    }
}

关于操作系统如何检测应用程序是否无响应。除了 UI 应用程序之外，我不知道还有其他测试，其中有方法可以检查 UI 线程是否处理 UI 代码。休眠在 UI 上的线程很容易被发现。 Windows“应用程序无响应”使用简单的本机方法“SendMessageTimeout”来检测应用程序是否有无响应的 UI。

UI 应用程序上的任何无限循环都应始终在单独的线程中运行。

Answer 11

while (!cancellationTokenSource.Token.IsCancellationRequested) 
{
    date = DateTime.Now;
    //do work
    Thread.Sleep(10);<< reduce CPU 
}

Answer 12

要保持控制台应用程序运行，只需将 Console.ReadLine() 添加到 Main() 中代码的末尾即可。

如果用户无法终止应用程序，您可以使用如下循环来执行此操作：

while (true){
   Console.ReadLine();
}