await Task.Run(() => { ... });

await Task.Delay(1000);

Thread t = new Thread(SomeMethod);
// 此时 t 处于 Unstarted 状态

        ┌────────────┐
        │  Unstarted │
        └──────┬─────┘
               │ Start()
               ▼
        ┌────────────┐
        │   Running  │
        └──┬────┬────┘
           │    │
           │    │Sleep()/Wait()/Join()
           │    ▼
           │  ┌────────────┐
           │  │WaitSleepJoin│
           │  └──────┬─────┘
           │         │(被唤醒)
           └─────────┘
               │
               ▼
        ┌────────────┐
        │   Stopped  │
        └────────────┘

## 核心：线程与线程池
1. `Thread`
传统线程类，直接映射操作系统线程
- 启动/终止/挂起/唤醒线程
- 设置优先级、名字、后台/前台状态
- 控制线程生命周期

这是整个命名空间的核心

2. `ThreadPool`
线程复用机制。避免频繁创建和销毁OS线程，适用于短时任务\
CLR会自动管理线程数量和调度策略\
现代`Task`（`System.Threading.Tasks.Task`）内部几乎都运行在线程池上

## 同步与锁机制
线程间通信的关键部分，确保共享资源安全

| 类 | 作用 |
| - | - |
| `Monitor` | 最基础的同步锁（`lock`语法糖的底层实现）|
| `Mutex` | 系统级互斥锁，可以跨进程使用 |
| `Semaphore`/`SemaphoreSlim` | 控制并发访问数量的锁，比如限制同时执行的线程数 |
| `SpinLock` | 自旋锁，用于短时间锁定的高性能场景（避免线程切换开销）|
| `ReaderWriterlockSlim` | 允许多个读者、单个写者的锁（多读写少场景）|
| `Interlocked` | 原子操作（加减、交换、比较交换等），CPU级别原语 |
| `Volatile` | 保证读写不会被编译器/CPU重排序 |
| `Barrier` | 多线程同步点，所有线程都到达后才能继续执行 |
| `CountdownEvent` | 线程等待多个事件完成的同步点（类似倒计时锁）|
| `ManualResetEvent`/`AutoResetEvent` | 信号机制，用于线程间通知 |
| `EventWaitHandle` | 信号量的通用基类，可以手动/自动复位 |

## 并发工具与调度

| 类 | 说明 |
| - | - |
| `Timer` | 定时器，在后台线程上周期性执行回调 |
| `ThreadLocal<T>` | 线程本地存储，每个线程有独立的变量副本 |
| `LocalDataStoreSlot` | 较旧的线程局部存储API（`ThreadLocal<T>`的前身）|
| `ExecutionContext`/`SynchronizationContext` | 控制上下文流动（比如异步方法中保持当前线程环境）|
| `LazyInitializer` | 延迟初始化工具类，线程安全地延迟构造对象 |
| `SpinWait` | 主动自旋等待（比Thread.Sleep更轻量）|

## 线程安全与并发基础结构
- `ThreadPriority`：线程优先级枚举
- `ThreadState`：线程状态枚举（Unstarted、Running、Stopped...）
- `ThreadAbortException`, `ThreadInterruptedException`：线程控制相关异常
- `ThreadStaticAttribute`：让静态变量在不同线程中拥有独立副本

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread t = new Thread(PrintNumbers);
        t.Start(); // 启动线程

        // 主线程继续执行
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"Main: {i}");
            Thread.Sleep(200);
        }
    }

    static void PrintNumbers()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"Worker: {i}");
            Thread.Sleep(300);
        }
    }
}

Thread t = new Thread(obj => {
    string name = (string)obj;
    Console.WriteLine($"Hello, {name}!");

});
t.Start("ljf12825");

string name = "ljf12825";
Thread t = new Thread(() => Console.WriteLine($"Hello, {name}!"));
t.Start();

Thread bgThread = new Thread(DoWork);
bgThread.IsBackground = true; // 设置为后台线程
bgThread.Start();

Thread t = new Thread(SomeWork)
{
    Name = "WorkerThread",
    Priority = ThreadPriority.AboveNormal
};
t.Start();

class BankAccount
{
    private readonly object _balanceLock = new object(); // 专用的锁对象
    private decimal _balance = 1000;

    public void Withdraw(decimal amount)
    {
        // 使用 lock 确保同一时间只有一个线程能进入此代码块
        lock (_balanceLock)
        {
            if (_balance >= amount)
            {
                Console.WriteLine($"Balance before withdrawal: {_balance}");
                _balance -= amount;
                Console.WriteLine($"Balance after withdrawal: {_balance}");
            }
        }
    }
}

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Console.WriteLine("主线程开始");
        
        try
        {
            // 创建并启动新线程
            Thread thread = new Thread(Worker);
            thread.Start();
            
            // 主线程继续执行
            Thread.Sleep(2000);
            Console.WriteLine("主线程结束");
        }
        catch (Exception ex)
        {
            // 这里不会捕获到工作线程的异常！
            Console.WriteLine($"主线程捕获到异常: {ex.Message}");
        }
        
        Console.ReadLine();
    }
    
    static void Worker()
    {
        Console.WriteLine("工作线程开始");
        Thread.Sleep(1000);
        
        // 在工作线程中抛出异常
        throw new InvalidOperationException("工作线程发生错误！");
        
        // 这行代码不会执行
        Console.WriteLine("工作线程结束");
    }
}

static void SafeWorker()
{
    try
    {
        Console.WriteLine("安全的工作线程开始");
        Thread.Sleep(1000);
        throw new InvalidOperationException("工作线程发生错误！");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"工作线程内部捕获异常: {ex.Message}");
        // 可以记录日志、通知主线程等
    }
}

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Console.WriteLine("主线程开始");
        
        Exception workerException = null;
        
        Thread thread = new Thread(() =>
        {
            try
            {
                Worker();
            }
            catch (Exception ex)
            {
                workerException = ex;
            }
        });
        
        thread.Start();
        thread.Join(); // 等待线程完成
        
        if (workerException != null)
        {
            Console.WriteLine($"捕获到工作线程异常: {workerException.Message}");
        }
        else
        {
            Console.WriteLine("工作线程正常完成");
        }
        
        Console.WriteLine("主线程结束");
    }
    
    static void Worker()
    {
        Console.WriteLine("工作线程开始");
        Thread.Sleep(1000);
        throw new InvalidOperationException("工作线程发生错误！");
    }
}

Thread -> 最底层封装（控制粒度最大）
ThreadPool -> 自动管理线程生命周期
Task -> 基于线程池的逻辑任务抽象
async/await -> 语法层面的异步封装

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        ThreadPool.QueueUserWorkItem(Work, "Task1");
        ThreadPool.QueueUserWorkItem(Work, "Task2");

        Console.WriteLine();
    }

    static void Work(object state)
    {
        Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} handling {state}");
        Thread.Sleep(500);
    }
}

Thread 4 handling Task1
Thread 5 handling Task2

ThreadPool.GetMaxThreads(out int worker, out int io);

初始化 -> 分配任务 -> 运行 -> 归还 -> 空闲等待（或销毁）

吞吐量 ^
       |            /\  
       |           /  \
       |          /    \
       |_________/______\_______> 线程数
                     ↑
                 最优点

while (true)
{
    MeasureThroughput();

    if (throughput > lastThroughput)
        threadCount += step; // 上坡：增加线程
    else
        threadCount -= step; // 下坡：减少线程
    
    step *= 0.9; // 越来越小
    lastThroughput = throughput;

    Sleep(sampleInterval);
}

Task.Run(() => DoWork());
// 本质上等价于 ThreadPool.QueueUserWorkItem()

ThreadPool.GetMinThreads(out int workerMin, out int ioMin);
ThreadPool.GetMaxThreads(out int workerMax, out int ioMax);

ThreadPool.SetMinThreads(8, 8); // 保证最低并发线程数

Task.Factory.StartNew(LongTask, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default)

Created -> WaitingToRun -> Running -> RanToCompletion / Faulteed / Canceled

Task t = new Task(() => Console.WriteLine("执行任务"));
Console.WriteLine(t.Status); // Created
t.Start();
t.Wait();
Console.WriteLine(t.Status); // RanToCompletion

Task.Run(() => Console.WriteLine("执行任务"))；

Task<int> t = Task.Run(() => {
    int sum = 0;
    for (int i = 0; i < 100; i++) sum += i;
    return sum;
});
Console.WriteLine(t.Result);

int result = await Task.Run(() => Compute());

try {
    Task t = Task.Run(() => throw new InvalidOperationException("出错了"));
    t.Wait();
} catch (AggregateException e) {
    Console.WriteLine(e.InnerException.Message); // 出错了
}

try {
    await Task.Run(() => throw new InvalidOperationException("出错了"));
} catch (Exception e) {
    Console.WriteLine(e.Message);
}

var cts = new CancellationTokenSource();
var token = cts.Token;

Task t = Task.Run(() => {
    for (int i = 0; i < 10; i++)
    {
        token.ThrowIfCancellationRequested();
        Console.WriteLine(i);
        Thread.Sleep(500);
    }
}, token);

// 请求取消
cts.Cancel();

Task t1 = Task.Run(() => Console.WriteLine("任务1"))；
Task t2 = t1.ContinueWith(prev => Console.WriteLine("任务2在任务1之后执行"));

Task t = Task.Run(() => DoWork());
t.Wait(); // 阻塞等待

Task t = Task.Run(() => {
    Console.WriteLine("任务在线程池中执行");
});
t.Wait(); // 阻塞直到任务完成

Task<int> t2 = Task.Run(() => {
    return Enumerable.Range(1, 100).Sum();
});
Console.WriteLine($"结果：{t2.Result}");

Task.Run() 
   ↓
TaskScheduler（默认 ThreadPoolTaskScheduler）
   ↓
ThreadPool（工作线程队列）
   ↓
执行任务

┌──────────┐       ┌────────────────┐       ┌───────────────┐
│  逻辑层  | ---> │ 调度器(TaskScheduler) │ ---> │ 执行层(ThreadPool) │
└──────────┘       └────────────────┘       └───────────────┘
    Task                   调度策略                   线程资源

Task.Run(() => Work());

new Task(() => Work()).Start();

TaskScheduler.Current.QueueTask(task);

TaskScheduler.Default

Task t = Task.Factory.StartNew(() => {
    Console.WriteLine(TaskScheduler.Current);
});

class SingleThreadTaskScheduler : TaskScheduler
{
    private readonly BlockingColleciton<Task> _task = new();

    public SingleThreadTaskScheduler()
    {
        var thread = new Thread(new ThreadStart(Execute));
        thread.IsBackground = true;
        thread.Start();
    }

    private void Execute()
    {
        foreach (var task in _tasks.GetConsumingEnumerable())
        {
            TryExecuteTask(task);
        }
    }

    protected override IEnumerable<Task> GetScheduledTasks() => _tasks;

    protected override void QueueTask(Task task) => _tasks.Add(task);

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        // 禁止内联执行，强制排队
        return false;
    }
}

var scheduler = new SingleThreadTaskScheduler();
Task.Factory.StartNew(() => DoSomething(), CancellationToken.None, TaskCreationOptions.None, shceduler);

t.ContinueWith(..., TaskContinuationOptions.ExecuteSynchronously);

Parallel.For(0, 10, i => {
    Console.WriteLine($"任务 {i} 在线程 {Thread.CurrentThread.ManagedThreadId}");
});

Parallel.ForEach(Enumerable.Range(1, 10), i => {
    Console.WriteLine($"处理 {i}");
});

var options = new ParallelOptions { MaxDegreeOfParallelism = 4 };
Parallel.ForEach(data, options, ProcessItem);

Task t = new Task(() => Console.WriteLine("手动启动任务"));
t.Start(); // 启动
t.Wait(); // 等待任务结束

Console.WriteLine(t.Status); // Created, Running, RanToCompletion, Faulted, Canceled

t.IsCompleted;
t.IsFaulted;
t.IsCanceled;

Task.Factory.StartNew(Action, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);

Task.Run(() => 42)
    .ContinueWith(prev => prev.Result * 2)
    .ContinueWith(prev => Console.WriteLine(prev.Result));

int r = await Task.Run(() => 42);
r *= 2;
Console.WriteLine(r);

var tasks = new[] {
    Task.Run(() => DoA()),
    Task.Run(() => DoB())
};
await Task.WhenAll(tasks);
Console.WriteLine("所有任务都完成")；

var t1 = Task.Run(() => SlowWork());
var t2 = Task.Run(() => FastWork());

Task finished = await Task.WhenAny(t1, t2);
Console.WriteLine($"先完成的是 {finished.Id}");

Task<int>[] tasks = {
    Task.Run(() => 1).
    Task.Run(() => 2),
    Task.Run(() => 3)
};

int[] results = await Task.WhenAll(tasks);
Console.WriteLine(results.Sum()); // 6

Task<int> t1 = Task.Run(() => 5);
Task<int> t2 = t1.ContinueWith(prev => prev.Result * 2);
Task<int> t3 = t2.ContinueWith(prev => prev.Result + 3);
Console.WriteLine(t3.Result); // 13

int result = await Task.Run(() => 5);
result = result * 2;
result = result + 3;

var cts = new CancellationTokenSource();
var token = cts.Token;

Task t = Task.Run(() => {
    for (int i = 0; i < 10; i++) {
        token.ThrowIfCancellationRequested();
        Console.WriteLine(i);
        Thread.Sleep(500);
    }
}, token);

// 取消任务
cts.Cancel();

Task t = Task.Run(async () => {
    while (!token.IsCancellationRequested) {
        Console.WriteLine("Running...");
        await Task.Delay(500);
    }
});

CancellationTokenSource cts = new();
var token = cts.Token;

Task t1 = Task.Run(() => Work1(token));
Task t2 = Task.Run(() => Work2(token));

// 一次取消全部
cts.Cancel();

try {
    Task t = Task.Run(() => throw new InvalidOperationException("出错了"));
    t.Wait();
} catch (AggregateException e) {
    Console.WriteLine(e.InnerException.Message);
}

try {
    await Task.Run(() => throw new InvalidOperationException("出错了"));
} catch (Exception e) {
    Console.WriteLine(e. GetType()); // InvalidOperationException
}

vaar tasks = new[] {
    Task.Run(() => throw new Exception("A")),
    Task.Run(() => throw new Exception("B"))
};

try {
    await Task.WhenAll(tasks);
} catch (Exception e) {
    foreach (var ex in ((AggregateException)e).InnerExceptions)
        Console.WriteLine(ex.Message);
}

async Task<int> ComputeAsync()
{
    await Task.Delay(1000);
    return 42;
}

token.ThrowIfCancellationRequested();

await Task.Delay(1000, token);

var cts = new CancellationTokenSource();
CancellationToken token = cts.Token;

cts.Cancel()

IsCancellationRequested = false

IsCancellationRequested = true

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 1. 创建信号控制器
        var cancellationTokenSource = new CancellationTokenSource();
        // 2. 获取信号令牌
        var token = cancellationTokenSource.Token;

        // 3. 启动一个长时间运行的任务，并传递 token
        Task longRunningTask = Task.Run(() =>
        {
            for (int i = 0; i < 1000; i++)
            {
                // 4. 在循环中定期检查取消请求
                if (token.IsCancellationRequested)
                {
                    // 执行清理工作（如果需要）
                    Console.WriteLine("任务被取消了！");
                    return; // 优雅地退出任务
                }

                // 模拟工作
                Thread.Sleep(500);
                Console.WriteLine($"工作进度： {i}");
            }
        }, token); // 注意：Token 也在这里传递给 Task.Run，以便任务在开始前就能被取消。

        Console.WriteLine("按 ‘c’ 键来取消操作...");
        if (Console.ReadKey(true).KeyChar == 'c')
        {
            // 5. 用户按下 ‘c’，触发取消
            Console.WriteLine("\n正在请求取消...");
            cancellationTokenSource.Cancel();
        }

        // 等待任务完成（无论是正常完成还是因取消而完成）
        try
        {
            longRunningTask.Wait();
        }
        catch (AggregateException ae)
        {
            // 如果任务因为取消而抛出 OperationCanceledException，它会在这里被捕获
            ae.Handle(e => e is OperationCanceledException);
            Console.WriteLine("任务已确认取消。");
        }

        Console.WriteLine("主线程结束。");
        cancellationTokenSource.Dispose(); // 好的实践：释放资源
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // 1. 创建信号控制器
        using var cts = new CancellationTokenSource();
        var token = cts.Token;

        // 2. 设置一个超时取消（5秒后自动取消）
        cts.CancelAfter(5000);

        try
        {
            // 3. 调用一个支持取消的异步方法
            await DoLongRunningWorkAsync(token);
            Console.WriteLine("工作成功完成！");
        }
        catch (OperationCanceledException) // 专门捕获取消异常
        {
            Console.WriteLine("工作被取消或超时了！");
        }
    }

    static async Task DoLongRunningWorkAsync(CancellationToken cancellationToken = default)
    {
        for (int i = 0; i < 10; i++)
        {
            // 4. 最推荐的方式：直接抛出异常来终止操作
            cancellationToken.ThrowIfCancellationRequested();

            // 或者，你也可以手动检查并处理
            // if (cancellationToken.IsCancellationRequested)
            // {
            //     // 进行一些清理...
            //     throw new OperationCanceledException("Operation was cancelled.", cancellationToken);
            // }

            // 模拟异步工作
            await Task.Delay(1000, cancellationToken); // 注意：Task.Delay 也接受 Token！
            Console.WriteLine($"完成了第 {i + 1} 项工作。");
        }
    }
}

var data = Download(); // 阻塞直到返回
Console.WriteLine(data);

DownloadAsync(url, result => {
    Console.WriteLine(result);
});

async Task<int> GetDataAsync()
{
    var data = await DownloadAsync(); // 暂停点
    return data.Length;
}

async Task<int> FooAsync()
{
    await Task.Delay(1000);
    return 42;
}

private struct FooAsyncStateMachine : IAsyncStateMachine
{
    public int _state;                        // 当前状态
    public AsyncTaskMethodBuilder<int> _builder;  // 异步任务构建器
    private TaskAwaiter _awaiter;             // await 对象

    void IAsyncStateMachine.MoveNext()
    {
        int result;
        try
        {
            if (_state == -1)  // 初始状态
            {
                _awaiter = Task.Delay(1000).GetAwaiter();
                if (!_awaiter.IsCompleted)
                {
                    _state = 0;  // 设置下一个状态
                    _awaiter.OnCompleted(MoveNext);  // 注册回调
                    return;       // 返回控制权
                }
            }

            if (_state == 0)
            {
                _awaiter.GetResult();  // 等待结果
            }

            result = 42;
            _builder.SetResult(result);  // 通知任务完成
        }
        catch (Exception e)
        {
            _builder.SetException(e);
        }
    }

    void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine) { }
}

Task<int> FooAsync()
{
    var stateMachine = new FooAsyncStateMachine();
    stateMachine._builder = AsyncTaskMethodBuilder<int>.Create();
    stateMachine._state = -1;
    stateMachine._builder.Start(ref stateMachine);
    return stateMachine._builder.Task;
}

public struct AsyncTaskMethodBuilder<T>
{
    private TaskCompletionSource<T> _tcs;

    public static AsyncTaskMethodBuilder<T> Create() => new AsyncTaskMethodBuilder<T>();

    public Task<T> Task => _tcs.Task;

    public void SetResult(T result) => _tcs.SetResult(result);

    public void SetException(Exception e) => _tcs.SetException(e);

    public void Start<TStateMachine>(ref TStateMachine sm) where TStateMachine : IAsyncStateMachine => sm.MoveNext();
}

public interface INotifyCompletion
{
    void OnCompleted(Action continuation);
}

await Task.Delay(1000); // UI线程不会卡死
label.Text = "Done"; // await后自动回到UI线程

SynchronizationContext.Current.Post(_ => MoveNext(), null);

await Task.Delay(1000).ConfigureAwait(false);

Task = 任务抽象（执行单位）
TPL = 任务调度与依赖框架
async/await = 状态机语法层（让异步更像同步）

Thread -> ThreadPool -> Task -> async/await

async 方法调用
    ↓
编译器生成状态机（IAsyncStateMachine）
    ↓
AsyncTaskMethodBuilder 创建 Task
    ↓
遇到 await：
       ├─> 任务未完成 → 注册 OnCompleted 回调 → 返回控制权
       └─> 任务已完成 → 直接执行下一步
    ↓
任务完成时回调 MoveNext()
    ↓
恢复状态 → 执行下一部分逻辑
    ↓
最终调用 SetResult() / SetException()
    ↓
外部 await 任务，获取结果或捕获异常

async Task<int> ComputeAsync() { ... }

var t = ComputeAsync();
var result = t.Result; // 只是 await 不会阻塞

SomeAsyncMethod().Wait();

var result = SomeAsyncMethod().Result;

async void Button_Click(...)
{
    await Task.Delay(1000);
    label.Text = "Done"; // 回到 UI 线程安全地修改控件
}

await SomeIOAsync().ConfigureAwait(false);

try
{
    await FailingAsync();
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}