Wie kann ich die CPU-Auslastung meines Programms programmatisch auf unter 70% begrenzen?

Dieser thread ist über vier Jahre alt, und es immer noch stört mich, dass die Antwort akzeptiert, kritisiert der Frage statt Sie zu beantworten. Es gibt viele Gründe würden Sie wollen, um die Begrenzung der CPU-Zeit, die dein Programm kann ich die Liste ein paar aus der Spitze von meinem Kopf.

Es mag wie eine Verschwendung, Sie nicht zu verwenden, alle freien CPU-Zyklen zur Verfügung, aber diese Mentalität ist fehlerhaft. Im Gegensatz zu älteren CPUs, die meisten modernen CPUs laufen nicht auf eine Feste Taktfrequenz - viele haben sich Energiespar-Modi, wo Sie drop-Takt und cpu-Spannung, wenn die Last niedrig ist. CPUs verbrauchen auch mehr Energie, wenn Berechnungen durchgeführt werden, als Sie es tun, laufen NOOPs. Dies ist besonders relevant für laptops erfordern, dass der Lüfter zum kühlen der CPU, wenn es unter hoher Last. Ausführen einer Aufgabe zu 100% für eine kurze Zeit verwenden können, weit mehr Energie als das laufen eine Aufgabe, bei 25% für vier mal so lang.

Stellen Sie sich vor Sie schreiben einen hintergrund-task, die entworfen, um index-Dateien in regelmäßigen Abständen in den hintergrund. Sollte die Indizierung Aufgabe verwenden Sie so viel von der CPU, da kann es mit einer niedrigeren Priorität, oder die Drosselklappe selbst zu 25% und dauert so lange wie es braucht? Gut, wenn es verbraucht 100% der CPU auf einem laptop, würde die CPU erwärmen, die fans schmeißen würde, und die Batterie entleeren würde ziemlich schnell, und der Benutzer ärgert sich. Wenn der Indexdienst gedrosselt selbst, der laptop kann in der Lage sein zu laufen mit komplett passiver Kühlung bei sehr niedriger cpu-Taktrate und Spannung.

Übrigens, den Windows Indexing Service jetzt drosselt sich in den neueren Versionen von Windows, die es nie haben, die in älteren Versionen. Ein Beispiel für einen Dienst, der noch immer nicht das Gas selbst, und Häufig ärgert die Menschen, finden Sie unter Windows Installer-Modul.

Ein Beispiel, wie Gas Teil Ihrer Anwendung intern in C#:

public void ThrottledLoop(Action action, int cpuPercentageLimit) {
    Stopwatch stopwatch = new Stopwatch();

    while(true) {
        stopwatch.Reset();
        stopwatch.Start();

        long actionStart = stopwatch.ElapsedTicks;
        action.Invoke();
        long actionEnd = stopwatch.ElapsedTicks;
        long actionDuration = actionEnd - actionStart;

        long relativeWaitTime = (int)(
            (1/(double)cpuPercentageLimit) * actionDuration);

        Thread.Sleep((int)((relativeWaitTime / (double)Stopwatch.Frequency) * 1000));
    }
}

InformationsquelleAutor der Antwort Ryan

Erstens, ich Stimme mit Ryan, die Frage ist durchaus gültig, und es gibt Fälle, wo die thread-Prioritäten sind nicht ausreichend um alle. Die anderen Antworten erscheinen sehr theoretisch und ohne praktischen nutzen in Situationen, in denen die Anwendung korrekt konzipiert, aber muss noch gedrosselt werden. Ryan bietet eine einfache Lösung für Fälle, in denen eine relativ kurze Aufgabe wird in hoher Frequenz. Es gibt Fälle, jedoch, wenn die Aufgabe nimmt eine sehr lange Zeit (sagen wir eine minute oder so) und Sie können nicht oder wollen nicht, es zu brechen in kleinere Stücke, zwischen denen Sie tun können, die Drosselung. Für diese Fälle ist die folgende Lösung hilfreich sein könnten:

Eher, dass die Drosselung in der business-code, können Sie den Entwurf eines Algorithmus selbst zu arbeiten auf Hochtouren und einfach Gas der thread läuft die operation "von außen". Die Allgemeine Vorgehensweise ist die gleiche wie in Ryan ' s Antwort: Berechnen einer suspension der Zeit auf Basis der aktuellen Nutzung und Aussetzung der thread für diese Zeitspanne vor der Wiederaufnahme wieder. Gegeben einen Prozess, die Sie wollen Gas geben, das ist die Logik:

public static class ProcessManager
{
    [Flags]
    public enum ThreadAccess : int
    {
        TERMINATE = (0x0001),
        SUSPEND_RESUME = (0x0002),
        GET_CONTEXT = (0x0008),
        SET_CONTEXT = (0x0010),
        SET_INFORMATION = (0x0020),
        QUERY_INFORMATION = (0x0040),
        SET_THREAD_TOKEN = (0x0080),
        IMPERSONATE = (0x0100),
        DIRECT_IMPERSONATION = (0x0200)
    }

    [DllImport("kernel32.dll")]
    static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle, uint dwThreadId);

    [DllImport("kernel32.dll")]
    static extern uint SuspendThread(IntPtr hThread);

    [DllImport("kernel32.dll")]
    static extern int ResumeThread(IntPtr hThread);

    [DllImport("kernel32.dll")]
    static extern int CloseHandle(IntPtr hThread);

    public static void ThrottleProcess(int processId, double limit)
    {
        var process = Process.GetProcessById(processId);
        var processName = process.ProcessName;
        var p = new PerformanceCounter("Process", "% Processor Time", processName);
        while (true)
        {
            var interval = 100;
            Thread.Sleep(interval);

            var currentUsage = p.NextValue() / Environment.ProcessorCount;
            if (currentUsage < limit) continue;
            var suspensionTime = (currentUsage-limit) / currentUsage * interval;
            SuspendProcess(processId);
            Thread.Sleep((int)suspensionTime);
            ResumeProcess(processId);
        }
    }

    private static void SuspendProcess(int pid)
    {
        var process = Process.GetProcessById(pid);

        if (process.ProcessName == string.Empty)
            return;

        foreach (ProcessThread pT in process.Threads)
        {
            IntPtr pOpenThread = OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)pT.Id);

            if (pOpenThread == IntPtr.Zero)
            {
                continue;
            }

            SuspendThread(pOpenThread);

            CloseHandle(pOpenThread);
        }
    }

    private static void ResumeProcess(int pid)
    {
        var process = Process.GetProcessById(pid);

        if (process.ProcessName == string.Empty)
            return;

        foreach (ProcessThread pT in process.Threads)
        {
            IntPtr pOpenThread = OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)pT.Id);

            if (pOpenThread == IntPtr.Zero)
            {
                continue;
            }

            var suspendCount = 0;

            do
            {
                suspendCount = ResumeThread(pOpenThread);
            } while (suspendCount > 0);

            CloseHandle(pOpenThread);
        }
    }
}

Der Vorteil dieser Lösung ist, dass das Intervall wird unabhängig von der Dauer Ihres "long running task". Darüber hinaus business-Logik und die Drosselung Logik sind getrennt. Die Spannung/resume-code ist inspiriert von dieser thread. Bitte beachten Sie, dass die Entsorgung und Beendigung der Drosselung muss umgesetzt werden in die Lösung über, es ist nicht für die Produktion von code.

InformationsquelleAutor der Antwort Marc

Ich denke ehrlich gesagt, dass statt sorgen über das versuchen, zu begrenzen, CPU-Auslastung, indem Sie Ihre app, Sie sollte sich mehr Ihrer Energien auf die Profilerstellung der Anwendung aufzudecken und zu beheben, Engpässe und Ineffizienzen, die eventuell existieren.

InformationsquelleAutor der Antwort itsmatt

Wenn Sie den code überhaupt läuft ist es zu 100%

Ich nehme an, rutschen in einigen schläft auswirken könnten.

Ich wundere mich über die 2-3 minute Abbildung. Ich habe gesehen, dass es auch, und ich nehme an, es ist das laden und initialisieren der Menge der Sachen, die ich wohl nicht wirklich brauchen.

InformationsquelleAutor der Antwort Mike Dunlavey

Wenn es keine andere Aufgabe ausgeführt wird, ist es falsch, dass Ihre app für die Nutzung aller cpu-Kapazität verfügbar ist? Es ist verfügbarwie in ist es da und es ist kostenlos zu benutzen. So verwenden Sie es!

Wenn Sie irgendwie einschränken der cpu-Nutzung Ihre Aufgabe wird es länger dauern. Aber es wird noch dauern, die gleiche Anzahl von cpu-Zyklen, so dass Sie nichts gewinnen. Sie nur verlangsamen Ihre Anwendung.

Tun Sie es nicht. Noch nicht einmal versuchen es. Es gibt keinen Grund, warum sollten Sie.

InformationsquelleAutor der Antwort Treb

Laut MSDNkönnen Sie nur ein thread-Priorität, d.h.

var t1 = new Thread(() => doSomething());
t1.Priority = ThreadPriority.BelowNormal;
t1.Start();

wo doSomething ist die Funktion, die Sie erstellen möchten ein thead für. Die Priorität können Sie eine der enumeration ThreadPriority Mitglieder Lowest, BelowNormal, Normal, AboveNormal, Highest - eine Beschreibung finden Sie in dem MSDN-link oben. Priorität Normal ist die Standardeinstellung.

InformationsquelleAutor der Antwort Matt