Насколько я понимаю, Thread.Sleep (0) принудительно переключает контекст в ОС.

Я хотел проверить, какое максимальное количество времени может пройти в приложении, прежде чем получить некоторое время процессора.

Поэтому я создал приложение, которое выполняет Thread.Sleep (0) в цикле while (c #) и вычисляет время, которое проходит между каждым вызовом.

Когда это приложение является единственным, работающим на двухъядерном тестовом ПК, максимальное наблюдаемое время составляет чуть менее 1 миллисекунды (в среднем 0,9 микросекунды), и оно использует весь доступный процессор (100%).

Когда я запускаю его вместе с фиктивным приложением CPU Filling (все с одинаковым приоритетом), максимальное время составляет около 25 мс, а среднее время - 20 мс. Он ведет себя так, как я ожидаю. И время очень стабильное.

Всякий раз, когда он получает некоторое время ЦП, он сразу же возвращает управление тому, кто выполняет какую-либо обработку, это похоже на игру «горячего картофеля» (загрузка ЦП падает до 0%). Если нет других запущенных приложений, управление возвращается немедленно.

Учитывая такое поведение, я ожидал, что это приложение окажет минимальное влияние на компьютер, на котором запущено реальное приложение. (И чтобы дать мне реальную «задержку», я мог ожидать увидеть в приложениях, работающих там). Но, к моему удивлению, это негативно (заметным образом) повлияло на производительность этой конкретной системы.

Я упускаю какой-то важный момент, касающийся Thread.Sleep (0)?

В качестве ссылки вот код этого приложения

private bool _running = true;
private readonly Stopwatch _timer = new Stopwatch();

private double _maxTime;
private long _count;
private double _average;
private double _current;

public Form1()
{
    InitializeComponent();
    Thread t = new Thread(Run);
    t.Start();
}

public void Run()
{
    while(_running)
    {
        _timer.Start();
        Thread.Sleep(0);
        _timer.Stop();

        _current = _timer.Elapsed.TotalMilliseconds;
        _timer.Reset();
        _count++;

        _average = _average*((_count - 1.0)/_count) + _current*(1.0/_count);
        if(_current>_maxTime)
        {
            _maxTime = _current;
        }
    }
}

Отредактировано для ясности (цель приложения): В настоящее время у меня запущено мягкое многопоточное приложение реального времени (ну, группа приложений), которое должно реагировать на некоторые входные данные примерно каждые 300 мс, но время от времени мы пропускаем некоторые сроки (менее 1% времени) и В настоящее время я пытаюсь улучшить это число.

Я хотел проверить, какова текущая изменчивость, вызванная другим процессом на той же машине: я твердо решил, что при установке приложения, написанного выше, на этой машине с полу-реальным временем, максимальное наблюдаемое время скажет мне, какая изменчивость вызвана системой. И.Е. У меня 300 мс, но максимальное наблюдаемое время до того, как поток получит некоторое время процессора, составляет 50 мс, поэтому для повышения производительности я должен установить максимальное время обработки 250 мс (поскольку я уже могу опоздать на 50 мс).