ach meinem Verständnis erzwingt Thread.Sleep (0) einen Kontextwechsel auf dem Betriebssyste

Ich wollte überprüfen, wie viel Zeit maximal in einer Anwendung vergangen sein kann, um CPU-Zeit zu erhalten.

So habe ich eine Anwendung erstellt, die Thread.Sleep (0) in einer while-Schleife (c #) ausführt und die Zeit berechnet, die zwischen den einzelnen Aufrufen vergeht.

Wenn diese Anwendung die einzige ist, die auf einem Zwei-Kern-Test-PC ausgeführt wird, beträgt die maximal beobachtete Zeit weniger als 1 Millisekunde (mit einem Durchschnitt von 0,9 Mikrosekunden) und verwendet die gesamte verfügbare CPU (100%).

Wenn ich es mit einer CPU-Filling-Dummy-Anwendung (alle mit derselben Priorität) ausführe, beträgt die maximale Zeit etwa 25 ms und die durchschnittliche Zeit 20 ms. Es verhält sich genau so, wie ich es erwarte. Und die Zeit ist sehr stabil.

Wenn es etwas CPU-Zeit kostet, gibt es die Kontrolle sofort an diejenigen zurück, die etwas zu verarbeiten haben, es ist wie beim Hot Potato-Spiel (die CPU-Auslastung sinkt auf 0%). Wenn keine andere Anwendung ausgeführt wird, kehrt die Steuerung sofort zurück.

Aufgrund dieses Verhaltens hatte ich erwartet, dass diese Anwendung nur minimale Auswirkungen auf einen Computer hat, auf dem eine reale Anwendung ausgeführt wird. (Und um mir die tatsächliche "Latenz" zu geben, die ich in den dort laufenden Anwendungen erwarten kann). Zu meiner Überraschung hat sich dies jedoch negativ auf die Leistung dieses bestimmten Systems ausgewirkt.

ermisse ich einen wichtigen Punkt in Bezug auf Thread.Sleep (0)?

Als Referenz hier ist der Code dieser Anwendung

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

Zur Verdeutlichung bearbeitet (Zweck der Anmeldung): Ich verwende derzeit eine Multithread-Anwendung in weicher Echtzeit (also eine Gruppe von Anwendungen), die alle ungefähr 300 ms auf einige Eingaben reagieren muss, aber von Zeit zu Zeit einige Fristen verpassen (weniger als 1% der Zeit). und ich versuche gerade, diese Zahl zu verbessern.

Ich wollte überprüfen, welche aktuelle Variabilität durch einen anderen Prozess auf derselben Maschine verursacht wird: Ich kann nur schwer sagen, dass die maximale beobachtete Zeit mir durch Anpassen der oben beschriebenen Anwendung auf dieser Halb-Echtzeitmaschine Auskunft darüber gibt, welche Variabilität durch das System verursacht wird. I.E. Ich habe 300 ms, aber die maximale beobachtete Zeit, bevor ein Thread etwas CPU-Zeit erhält, liegt bei 50 ms. Um die Leistung zu verbessern, sollte ich meine Verarbeitungszeit auf maximal 250 ms einstellen (da ich möglicherweise bereits 50 ms zu spät komme).