Бесконечный цикл, удобный для процессора

Чтобы избежать бесконечного цикла, просто используйте WaitHandle. Чтобы позволить процессу выйти из внешнего мира, используйте EventWaitHandle с уникальной строкой. Ниже приведен пример.

Если вы запускаете его в первый раз, он просто распечатывает сообщение каждые 10 секунд. Если вы тем временем запустите второй экземпляр программы, он сообщит другому процессу о том, что нужно изящно выйти, и также немедленно завершит работу. Использование ЦП для этого подхода: 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.");
}

Вы можете использовать класс System.Threading.Timer, который предоставляет возможность выполнять обратный вызов асинхронно в заданный период времени.

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

В качестве альтернативы есть класс System.Timers.Timer, который предоставляет прошедшее событие, которое возникает, когда заданный период времени истекло.

Почему вы оправдываете использование бесконечного цикла? В этом примере не будет ли более экономичным настроить программу как запланированную задачу, которая будет запускаться каждую минуту?

Почему бы вам не написать небольшое приложение и не использовать системный планировщик задач, чтобы запускать его каждую минуту, час и т. д.?

Другой вариант — написать службу Windows, которая работает в фоновом режиме. Служба может использовать простой класс Alarm, подобный следующему в MSDN:

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 для выполнения вашей задачи. Нет необходимости реализовывать «бесконечный цикл» только для того, чтобы поддерживать работоспособность приложения. За вас этим занимается сервис.

Я сделал это для приложения, которое должно было обрабатывать файлы по мере того, как они помещались в папку. Лучше всего использовать таймер (как было предложено) с 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);
}

Теперь вы упомянули, что это (или может быть) для мобильного приложения? Возможно, у вас нет наблюдателя за файловой системой. В этом случае, возможно, вам просто нужно «убить» процесс (вы сказали: «В особых ситуациях (например, при обновлении приложения) мне нужно запросить остановку приложения». просто убить процесс)

Мне кажется, вы хотите, чтобы 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");
    }
}

Вы можете использовать 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% одного ядра на моей машине (полностью пустой цикл). Кроме того, вы можете использовать этот код (Source) в теле вашего петля:

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% одного ядра на моей машине.

Чтобы пояснить комментарий, сделанный CodeInChaos:

Вы можете установить заданный приоритет потока. Потоки планируются для выполнения на основе их приоритета. Алгоритм планирования, используемый для определения порядка выполнения потоков, зависит от операционной системы. Все потоки по умолчанию имеют «нормальный» приоритет, но если вы установите низкий уровень цикла; он не должен красть время у потоков, установленных в нормальном режиме.

Подход Timer, вероятно, ваш лучший выбор, но поскольку вы упомянули Thread.Sleep, есть интересный Thread.SpinWait или SpinWait struct альтернатива для аналогичных проблем, которая иногда может быть лучше, чем короткие вызовы Thread.Sleep.

Также см. этот вопрос: Какова цель метода Thread.SpinWait?

Здесь много «продвинутых» ответов, но для большинства должно быть достаточно простого использования Thread.Sleep(lowvalue).

Таймеры также являются решением, но код, стоящий за таймером, также представляет собой бесконечный цикл — я бы предположил — который запускает ваш код через истекшие интервалы, но у них есть правильная настройка бесконечного цикла.

Если вам нужен большой сон, вы можете разбить его на более короткие периоды сна.

Итак, что-то вроде этого — простое и легкое решение с 0% ЦП для приложения без пользовательского интерфейса.

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-код. Спящий поток в пользовательском интерфейсе будет легко обнаружен. Windows «Приложение не отвечает» использует простой собственный метод «SendMessageTimeout», чтобы определить, есть ли у приложения неотвечающий пользовательский интерфейс.

Любой бесконечный цикл в приложении пользовательского интерфейса всегда должен выполняться в отдельном потоке.

Чтобы консольные приложения продолжали работать, просто добавьте Console.ReadLine() в конец кода в Main().

Если пользователь не должен иметь возможность завершить приложение, вы можете сделать это с помощью цикла, подобного следующему:

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