如何在C#/.NET中限制应用/Windows服务的CPU插槽/核心数？

嘿，咱们先从SQL Server的CPU限制说起，它的授权模式会直接限制可用的CPU插槽或核心数量，具体各版本对单实例（SQL Server数据库引擎）的最大计算能力限制如下：

问题：如何在C#/.NET环境中限制应用程序或Windows服务可使用的CPU插槽或核心数量？ #

• 设置处理器亲和性/线程亲和性是否是唯一方法？（该方式可通过任务管理器(ctrl+shift+esc)轻松绕过）

注：本问题不讨论此做法是否合理，此类讨论常见于其他问题中

我的解答 #

其实在.NET环境里，限制应用可用CPU核心的方式不止处理器亲和性这一种，下面给你拆解几种常用方案：

1. 处理器亲和性（进程/线程级）

这是最直接的方式，你可以通过Process类给整个进程设置亲和性掩码，或者针对单个线程绑定特定核心。比如在C#里可以这么写：

// 将当前进程绑定到第0、1号CPU核心（二进制掩码0b11对应核心0和1）
var currentProcess = Process.GetCurrentProcess();
currentProcess.ProcessorAffinity = new IntPtr(0b11);

不过正如你提到的，这种方式确实很容易被绕过——用户只要打开任务管理器，找到进程右键调整亲和性，限制就失效了。

2. 自定义TPL任务调度器（间接限制）

如果你用的是.NET的Task Parallel Library（TPL），可以自定义任务调度器，通过限制并发执行的任务数量，间接控制应用对CPU核心的使用。比如创建一个只允许指定数量线程运行的调度器：

public class LimitedConcurrencyTaskScheduler : TaskScheduler
{
    private readonly BlockingCollection<Task> _taskQueue;
    private readonly int _maxConcurrency;

    public LimitedConcurrencyTaskScheduler(int maxConcurrency)
    {
        _maxConcurrency = maxConcurrency;
        _taskQueue = new BlockingCollection<Task>();
        
        // 启动指定数量的工作线程处理任务
        for (int i = 0; i < maxConcurrency; i++)
        {
            ThreadPool.UnsafeQueueUserWorkItem(_ =>
            {
                foreach (var task in _taskQueue.GetConsumingEnumerable())
                {
                    TryExecuteTask(task);
                }
            }, null);
        }
    }

    protected override IEnumerable<Task>? GetScheduledTasks() => _taskQueue;
    protected override void QueueTask(Task task) => _taskQueue.Add(task);
    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) => false;
}

使用的时候，把任务提交到这个调度器即可：

// 限制为2个并发任务，间接控制使用2个CPU核心
var scheduler = new LimitedConcurrencyTaskScheduler(2);
Task.Factory.StartNew(() => 
{
    // 这里写你的业务逻辑
}, CancellationToken.None, TaskCreationOptions.None, scheduler);

这种方式不会直接绑定到特定核心，但能通过控制并发度来限制CPU使用率，虽然不是绝对的硬限制，但大部分场景下能达到预期效果，而且比亲和性更灵活。

3. Windows Job Objects（系统级强限制）

如果需要更严格、难以绕过的限制，可以用Windows的Job Objects——这是系统级的资源限制机制，能对进程组设置包括CPU亲和性、使用率上限在内的多种限制。你需要通过P/Invoke调用Windows API来实现：

using System.Runtime.InteropServices;

[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr CreateJobObject(IntPtr lpJobAttributes, string lpName);

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

[DllImport("kernel32.dll", SetLastError = true)]
static extern bool SetInformationJobObject(IntPtr hJob, JOBOBJECTINFOCLASS JobObjectInfoClass, IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength);

public enum JOBOBJECTINFOCLASS
{
    JobObjectBasicLimitInformation = 2
}

[StructLayout(LayoutKind.Sequential)]
public struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
    public long PerProcessUserTimeLimit;
    public long PerJobUserTimeLimit;
    public uint LimitFlags;
    public UIntPtr MinimumWorkingSetSize;
    public UIntPtr MaximumWorkingSetSize;
    public uint ActiveProcessLimit;
    public UIntPtr Affinity;
    public uint PriorityClass;
    public uint SchedulingClass;
}

// 使用示例：将当前进程绑定到核心0和1
var jobHandle = CreateJobObject(IntPtr.Zero, null);
if (jobHandle != IntPtr.Zero)
{
    var limitInfo = new JOBOBJECT_BASIC_LIMIT_INFORMATION();
    limitInfo.LimitFlags = 0x00000010; // 启用亲和性限制
    limitInfo.Affinity = (UIntPtr)0b11; // 绑定到核心0和1
    
    int structSize = Marshal.SizeOf(limitInfo);
    IntPtr infoPtr = Marshal.AllocHGlobal(structSize);
    Marshal.StructureToPtr(limitInfo, infoPtr, false);
    
    SetInformationJobObject(jobHandle, JOBOBJECTINFOCLASS.JobObjectBasicLimitInformation, infoPtr, (uint)structSize);
    AssignProcessToJobObject(jobHandle, Process.GetCurrentProcess().Handle);
    
    Marshal.FreeHGlobal(infoPtr);
}

这种方式的限制是系统级的，用户很难通过任务管理器绕过，适合需要强约束的场景。

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