为何能启动远超机器逻辑核心数的线程？附C#代码示例

我为理解线程相关知识编写了如下C#程序，该程序创建1000个线程，每个线程包含一个超长循环：

for(int i = 0; i < 1000; i++)
{
    var j = i;
    Console.WriteLine("Creating Thread " + j);   
    new Thread(() =>
    {
        Console.WriteLine("Running thread " + j);
        for(var k = 0; k < 1000000000000000000; k++) { }
        Console.WriteLine("Completing thread " + j);
    }).Start();
}

Console.ReadLine();

运行后，程序输出如下且持续增加：

Creating Thread 0
Creating Thread 1
Creating Thread 2
Running thread 1
Running thread 0
Creating Thread 3
Creating Thread 4
Running thread 2
Creating Thread 5
Running thread 3
Creating Thread 6
Running thread 4
Running thread 5
Creating Thread 7
Creating Thread 8
Running thread 6
Creating Thread 9
Running thread 8
Running thread 7
Creating Thread 10
Running thread 9
Creating Thread 11
Running thread 10
Running thread 11
Creating Thread 12
Creating Thread 13
Running thread 12
Creating Thread 14
Running thread 13
Creating Thread 15
Running thread 14
Creating Thread 16
Running thread 15
Creating Thread 17
Running thread 16
Creating Thread 18
Running thread 17
Creating Thread 19
Running thread 18
Creating Thread 20
Running thread 19
Creating Thread 21
Running thread 20
Creating Thread 22

我的机器仅拥有8个逻辑核心，却能启动并运行远超核心数的线程，想了解这一现象的实现原理。

这核心在于操作系统的时间分片（Time Slicing）机制，配合CPU的上下文切换（Context Switching）来实现：

• 时间分片：操作系统会给每个线程分配一小段CPU执行时间（通常是毫秒级），当时间片用完后，操作系统会暂停当前线程，把CPU资源切换给另一个等待的线程。虽然只有8个逻辑核心，但操作系统通过快速切换线程，让每个线程都能获得执行机会，在用户看来就像多个线程同时在运行。
• 上下文切换：每次切换线程时，操作系统会保存当前线程的执行状态（比如寄存器值、程序计数器等），然后加载下一个线程的状态。这个过程速度极快，用户几乎感知不到延迟，所以会产生所有线程都在“同时”运行的错觉。
• 线程调度逻辑：任意时刻最多只有8个线程能真正占用CPU核心执行，剩下的线程都处于等待调度的状态。操作系统会根据线程优先级、资源需求等动态调整调度顺序，不断在待执行线程间切换，让所有线程都能逐步推进任务。

需要注意的是，虽然能启动大量线程，但线程数量过多会导致上下文切换开销急剧增加——操作系统要花大量时间处理切换逻辑，真正用于执行任务的时间会被压缩，反而会降低整体性能。

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