如何在C#中降低Windows系统所有程序的CPU占用率？

以下是针对需求的可行技术方案，均基于C#实现，且避免干扰系统关键进程：

1. 调整非系统进程的优先级（需管理员权限） #

你之前的操作仅影响自身进程，是因为修改其他进程优先级需要管理员权限。通过遍历系统进程，过滤掉核心系统进程后，将普通用户进程的优先级设为BelowNormal或Idle，可降低它们对CPU资源的抢占。

实现代码： #

using System.Diagnostics;
using System.Collections.Generic;

public class PriorityOptimizer
{
    // 定义需排除的系统关键进程（可根据需求补充）
    private static readonly HashSet<string> ExcludedProcesses = new()
    {
        "system", "svchost", "csrss", "wininit", "services", "lsass", "smss", "explorer"
    };

    public static void LowerNonSystemProcessPriorities()
    {
        foreach (var process in Process.GetProcesses())
        {
            try
            {
                // 跳过系统进程、已退出进程和自身进程
                if (ExcludedProcesses.Contains(process.ProcessName.ToLower()) 
                    || process.HasExited 
                    || process.Id == Process.GetCurrentProcess().Id)
                    continue;

                // 设置为低于正常优先级（Idle优先级需谨慎使用，可能导致程序响应极慢）
                process.PriorityClass = ProcessPriorityClass.BelowNormal;
            }
            catch (System.Security.SecurityException)
            {
                Debug.WriteLine($"无权限调整进程 {process.ProcessName} 的优先级");
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"调整进程 {process.ProcessName} 失败: {ex.Message}");
            }
        }
    }
}

2. 利用Windows Job对象限制进程CPU使用率 #

Windows Job对象是系统层面的进程容器，可对一组进程设置CPU使用率上限，比单纯调整优先级更精准。通过P/Invoke调用Windows API实现，不会直接修改进程优先级，而是通过系统调度限制CPU占用。

实现代码： #

using System;
using System.Runtime.InteropServices;
using System.Diagnostics;

public class JobCpuLimiter
{
    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
    private static extern IntPtr CreateJobObject(IntPtr lpJobAttributes, string lpName);

    [DllImport("kernel32.dll")]
    private static extern bool SetInformationJobObject(IntPtr hJob, JOBOBJECTINFOCLASS infoClass, IntPtr infoPtr, uint infoLength);

    [DllImport("kernel32.dll")]
    private static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess);

    private enum JOBOBJECTINFOCLASS
    {
        JobObjectCpuRateControlInformation = 15
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct JOBOBJECT_CPU_RATE_CONTROL_INFORMATION
    {
        public uint ControlFlags;
        public uint CpuRate;
    }

    private const uint JOB_OBJECT_CPU_RATE_CONTROL_ENABLE = 0x00000001;

    /// <summary>
    /// 限制指定进程的CPU使用率上限
    /// </summary>
    /// <param name="processId">进程ID</param>
    /// <param name="maxCpuPercent">最大CPU百分比（如20表示20%）</param>
    public static bool LimitProcessCpu(int processId, uint maxCpuPercent)
    {
        try
        {
            using var process = Process.GetProcessById(processId);
            var jobHandle = CreateJobObject(IntPtr.Zero, null);
            if (jobHandle == IntPtr.Zero) return false;

            // 配置CPU限制：CpuRate单位为千分之一，20%即2000
            var cpuControlInfo = new JOBOBJECT_CPU_RATE_CONTROL_INFORMATION
            {
                ControlFlags = JOB_OBJECT_CPU_RATE_CONTROL_ENABLE,
                CpuRate = maxCpuPercent * 100
            };

            var infoSize = (uint)Marshal.SizeOf(cpuControlInfo);
            var infoPtr = Marshal.AllocHGlobal((int)infoSize);
            Marshal.StructureToPtr(cpuControlInfo, infoPtr, false);

            var success = SetInformationJobObject(jobHandle, JOBOBJECTINFOCLASS.JobObjectCpuRateControlInformation, infoPtr, infoSize);
            Marshal.FreeHGlobal(infoPtr);

            if (!success) return false;
            return AssignProcessToJobObject(jobHandle, process.Handle);
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"限制进程CPU失败: {ex.Message}");
            return false;
        }
    }
}

// 使用示例：限制进程ID为1234的程序最多使用20%CPU
// JobCpuLimiter.LimitProcessCpu(1234, 20);

3. 基于系统负载的动态优化策略 #

不要持续执行优化操作，而是监控系统CPU负载，仅当负载超过阈值（如80%）时触发优化，避免不必要的系统干预。

实现代码： #

using System.Diagnostics;
using System.Threading;

public class SystemLoadMonitor
{
    // 复用PriorityOptimizer中的排除进程集合
    private static readonly HashSet<string> ExcludedProcesses = PriorityOptimizer.ExcludedProcesses;

    /// <summary>
    /// 获取当前系统CPU使用率
    /// </summary>
    public static float GetSystemCpuUsage()
    {
        using var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
        // 第一次读取无效，需等待刷新
        cpuCounter.NextValue();
        Thread.Sleep(1000);
        return cpuCounter.NextValue();
    }

    /// <summary>
    /// 后台监控并动态优化
    /// </summary>
    public static void StartMonitoring()
    {
        while (true)
        {
            var cpuUsage = GetSystemCpuUsage();
            // 当CPU使用率超过80%时触发优化
            if (cpuUsage > 80)
            {
                PriorityOptimizer.LowerNonSystemProcessPriorities();
                
                // 可选：对高CPU占用的进程单独设置限制
                foreach (var process in Process.GetProcesses())
                {
                    try
                    {
                        if (process.HasExited || ExcludedProcesses.Contains(process.ProcessName.ToLower()))
                            continue;

                        // 计算进程CPU占用率（简化逻辑）
                        var processCpu = process.TotalProcessorTime.TotalMilliseconds 
                            / (Environment.TickCount - process.StartTime.Ticks / 10000) * 100;
                        
                        if (processCpu > 30) // 进程CPU占用超过30%时限制
                        {
                            JobCpuLimiter.LimitProcessCpu(process.Id, 25);
                        }
                    }
                    catch { }
                }
            }
            Thread.Sleep(5000); // 每5秒检查一次
        }
    }
}

关键注意事项 #

• 管理员权限：所有修改其他进程的操作都需要管理员权限，可在项目的app.manifest中添加以下配置：

  <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
  

• 进程过滤：务必保留系统核心进程的优先级，避免修改system、svchost等进程，否则可能导致系统不稳定。
• 用户白名单：建议添加白名单功能，允许用户指定无需优化的程序（如游戏、专业软件），避免影响用户体验。
• 恢复机制：当系统负载降低时，可恢复进程的原优先级，避免程序长期处于低性能状态。

内容的提问来源于stack exchange，提问作者Frost Dream