A mi entender, un Thread.Sleep (0) fuerza un cambio de contexto en el sistema operativo.

Quería verificar cuál era la cantidad máxima de tiempo que podía pasar en una aplicación antes de recibir algo de tiempo de CPU.

Así que construí una aplicación que hace Thread.Sleep (0) en un ciclo while (c #) y calculo el tiempo que pasa entre cada llamada.

Cuando esta aplicación es la única que se ejecuta en una PC de prueba de dos núcleos, el tiempo máximo observado es inferior a 1 milisegundo (con un promedio de 0.9 microsegundos) y utiliza toda la CPU disponible (100%).

Cuando lo ejecuto junto con una aplicación ficticia de llenado de CPU (todas con la misma prioridad), el tiempo máximo es de alrededor de 25 ms y el tiempo promedio es de 20 ms. Se comporta exactamente como lo espero. Y el tiempo es muy estable.

Cada vez que obtiene algo de tiempo de CPU, inmediatamente devuelve el control a quien tenga que procesar algo, es como el juego de la papa caliente (el uso de la CPU cae al 0%). Si no hay otra aplicación ejecutándose, el control vuelve inmediatamente.

Dado este comportamiento, esperaba que esta aplicación tuviera un impacto mínimo en una computadora que ejecuta una aplicación de la vida real. (Y para darme la "latencia" real que podría esperar ver en las aplicaciones que se ejecutan allí). Pero para mi sorpresa, afectó negativamente (de manera observable) el rendimiento de este sistema específico.

¿Me estoy perdiendo algún punto importante sobre Thread.Sleep (0)?

Como referencia, aquí está el código de esta aplicación

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;
        }
    }
}

Editado para mayor claridad (propósito de la aplicación): Actualmente estoy ejecutando una aplicación de subprocesos múltiples en tiempo real (bueno, un grupo de aplicaciones) que necesita reaccionar a algunas entradas cada aproximadamente 300 ms, pero perdemos algunos plazos de vez en cuando (menos del 1% del tiempo) y Actualmente estoy tratando de mejorar ese número.

Quería verificar cuál es la variabilidad actual causada por otro proceso en la misma máquina: Resisto que al ajustar la aplicación escrita anteriormente en esta máquina de tiempo semi real, el tiempo máximo observado me diría qué variabilidad es causada por el sistema. ES DECIR. Tengo 300 ms, pero el tiempo máximo observado antes de que un subproceso tenga algo de tiempo de CPU está parado en 50 ms, por lo que para mejorar el rendimiento, debería establecer mi tiempo de procesamiento en un máximo de 250 ms (ya que podría estar 50 ms tarde).