CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
cancellationToken.Register(() => System.Console.WriteLine("取消了？？？"));
cancellationToken.Register(() => System.Console.WriteLine("取消了?。?！"));
cancellationToken.Register(state => System.Console.WriteLine($"取消了。。。{state}"),"啊啊啊");
System.Console.WriteLine("做了點(diǎn)別的,然后取消了.");
cancellationTokenSource.Cancel();

//設(shè)置3000毫秒(即3秒)后取消
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(3000);
CancellationToken cancellationToken = cancellationTokenSource.Token;
cancellationToken.Register(() => System.Console.WriteLine("我被取消了."));
System.Console.WriteLine("先等五秒鐘.");
await Task.Delay(5000);
System.Console.WriteLine("手動(dòng)取消.")
cancellationTokenSource.Cancel();

CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Token.Register(() => System.Console.WriteLine("我被取消了."));
//五秒之后取消
cancellationTokenSource.CancelAfter(5000);
System.Console.WriteLine("不會(huì)阻塞,我會(huì)執(zhí)行.");

//聲明幾個(gè)CancellationTokenSource
CancellationTokenSource tokenSource = new CancellationTokenSource();
CancellationTokenSource tokenSource2 = new CancellationTokenSource();
CancellationTokenSource tokenSource3 = new CancellationTokenSource();

tokenSource2.Token.Register(() => System.Console.WriteLine("tokenSource2被取消了"));

//創(chuàng)建一個(gè)關(guān)聯(lián)的CancellationTokenSource
CancellationTokenSource tokenSourceNew = CancellationTokenSource.CreateLinkedTokenSource(tokenSource.Token, tokenSource2.Token, tokenSource3.Token);
tokenSourceNew.Token.Register(() => System.Console.WriteLine("tokenSourceNew被取消了"));
//取消tokenSource2
tokenSource2.Cancel();

CancellationTokenSource tokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = tokenSource.Token;
//打印被取消
cancellationToken.Register(() => System.Console.WriteLine("被取消了."));
//模擬傳遞的場(chǎng)景
Task.Run(async ()=> {
    while (!cancellationToken.IsCancellationRequested)
    {
        System.Console.WriteLine("一直在執(zhí)行...");
        await Task.Delay(1000);
    }
});
//5s之后取消
tokenSource.CancelAfter(5000);

CancellationTokenSource tokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = tokenSource.Token;
cancellationToken.Register(() => System.Console.WriteLine("被取消了."));
tokenSource.CancelAfter(5000);
while (true)
{
    //如果操作被取消則直接拋出異常
    cancellationToken.ThrowIfCancellationRequested();
    System.Console.WriteLine("一直在執(zhí)行...");
    await Task.Delay(1000);
}

//全局狀態(tài)
private volatile int _state;
//未取消狀態(tài)值
private const int NotCanceledState = 1;

/// <summary>
/// 無參構(gòu)造初始化狀態(tài)
/// </summary>
public CancellationTokenSource() => _state = NotCanceledState;

/// <summary>
/// 定時(shí)取消構(gòu)造
/// </summary>
public CancellationTokenSource(TimeSpan delay)
{
    //獲取timespan的毫秒數(shù)
    long totalMilliseconds = (long)delay.TotalMilliseconds;
    if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
    {
        throw new ArgumentOutOfRangeException(nameof(delay));
    }
    //調(diào)用InitializeWithTimer
    InitializeWithTimer((int)totalMilliseconds);
}

public CancellationTokenSource(int millisecondsDelay)
{
    if (millisecondsDelay < -1)
    {
        throw new ArgumentOutOfRangeException(nameof(millisecondsDelay));
    }
    //調(diào)用InitializeWithTimer
    InitializeWithTimer(millisecondsDelay);
}

//任務(wù)完成狀態(tài)值
private const int NotifyingCompleteState = 2;
//定時(shí)器
private volatile TimerQueueTimer? _timer;
//定時(shí)器回調(diào)初始化
private static readonly TimerCallback s_timerCallback = TimerCallback;
//定時(shí)器回調(diào)委托本質(zhì)是調(diào)用的CancellationTokenSource的NotifyCancellation方法
private static void TimerCallback(object? state) => 
    ((CancellationTokenSource)state!).NotifyCancellation(throwOnFirstException: false);

private void InitializeWithTimer(uint millisecondsDelay)
{
    if (millisecondsDelay == 0)
    {
        //如果定時(shí)的毫秒為0，則設(shè)置全局狀態(tài)為NotifyingCompleteState
        _state = NotifyingCompleteState;
    }
    else
    {
        //如果超時(shí)毫秒不為0則初始化定時(shí)器，并設(shè)置定時(shí)器定時(shí)的回調(diào)
        _timer = new TimerQueueTimer(s_timerCallback, this, millisecondsDelay, Timeout.UnsignedInfinite, flowExecutionContext: false);
    }
}

//信號(hào)控制類，通過信號(hào)判斷是否需要繼續(xù)執(zhí)行或阻塞
private volatile ManualResetEvent? _kernelEvent;
//throwOnFirstException函數(shù)是指示如果被取消了是否拋出異常
private void NotifyCancellation(bool throwOnFirstException)
{
    //如果任務(wù)已經(jīng)取消則直接直接釋放定時(shí)器
    if (!IsCancellationRequested && Interlocked.CompareExchange(ref _state, NotifyingState, NotCanceledState) == NotCanceledState)
    {
        TimerQueueTimer? timer = _timer;
        if (timer != null)
        {
            _timer = null;
            timer.Close();
        }
        //信號(hào)量涉及到了一個(gè)重要的屬性WaitHandle接下來會(huì)說
        _kernelEvent?.Set(); 
        //執(zhí)行取消操作，是取消操作的核心，講取消操作的時(shí)候咱們會(huì)著重說這個(gè)
        ExecuteCallbackHandlers(throwOnFirstException);
        Debug.Assert(IsCancellationCompleted, "Expected cancellation to have finished");
    }
}

private volatile ManualResetEvent? _kernelEvent;
internal WaitHandle WaitHandle
{
    get
    {
        ThrowIfDisposed();
        //如果初始化過了則直接返回
        if (_kernelEvent != null)
        {
            return _kernelEvent;
        }

        //初始化一個(gè)ManualResetEvent，給定初始值為false
        var mre = new ManualResetEvent(false);
        //線程安全操作如果有別的線程初始了則釋放上面初始化的操作
        if (Interlocked.CompareExchange(ref _kernelEvent, mre, null) != null)
        {
            mre.Dispose();
        }

        //如果任務(wù)已取消則后續(xù)操作不阻塞
        if (IsCancellationRequested)
        {
            _kernelEvent.Set();
        }
        return _kernelEvent;
    }
}

public CancellationToken Token
{
    get
    {
        ThrowIfDisposed();
        return new CancellationToken(this);
    }
}

private readonly CancellationTokenSource? _source;
internal CancellationToken(CancellationTokenSource? source) => _source = source;
public WaitHandle WaitHandle => (_source ?? CancellationTokenSource.s_neverCanceledSource).WaitHandle;

CancellationTokenSource tokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = tokenSource.Token;
cancellationToken.Register(() => System.Console.WriteLine("被取消了."));
tokenSource.CancelAfter(5000);
Task.Run(()=> {
    System.Console.WriteLine("阻塞之前");
    cancellationToken.WaitHandle.WaitOne();
    System.Console.WriteLine("阻塞取消,執(zhí)行到了.");
});
System.Console.WriteLine("執(zhí)行到了這里");

public CancellationTokenRegistration Register(Action callback) =>
Register(
    s_actionToActionObjShunt,
    callback ?? throw new ArgumentNullException(nameof(callback)),
    useSynchronizationContext: false,
    useExecutionContext: true);

private CancellationTokenRegistration Register(Action<object?> callback, object? state, bool useSynchronizationContext, bool useExecutionContext)
{
    if (callback == null)
        throw new ArgumentNullException(nameof(callback));

    //_source就是傳遞下來的CancellationTokenSource
    CancellationTokenSource? source = _source;
    //本質(zhì)是調(diào)用的CancellationTokenSource的InternalRegister方法
    return source != null ?
        source.InternalRegister(callback, state, useSynchronizationContext ? SynchronizationContext.Current : null, useExecutionContext ? ExecutionContext.Capture() : null) :
        default; 

//初始化CallbackPartition數(shù)組
private volatile CallbackPartition?[]? _callbackPartitions;
//獲取初始化上面數(shù)組的長(zhǎng)度，根據(jù)當(dāng)前CPU核心數(shù)獲取的
private static readonly int s_numPartitions = GetPartitionCount();

internal CancellationTokenRegistration InternalRegister(
    Action<object?> callback, object? stateForCallback, SynchronizationContext? syncContext, ExecutionContext? executionContext)
{
    //判斷有沒有被取消
    if (!IsCancellationRequested)
    {
        //如果已被釋放直接返回
        if (_disposed)
        {
            return default;
        }
        CallbackPartition?[]? partitions = _callbackPartitions;
        if (partitions == null)
        {
            //首次調(diào)用初始化CallbackPartition數(shù)組
            partitions = new CallbackPartition[s_numPartitions];
            //判斷_callbackPartitions如果為null,則把partitions賦值給_callbackPartitions
            partitions = Interlocked.CompareExchange(ref _callbackPartitions, partitions, null) ?? partitions;
        }
        //獲取當(dāng)前線程使用的分區(qū)下標(biāo)
        int partitionIndex = Environment.CurrentManagedThreadId & s_numPartitionsMask;
        //獲取一個(gè)CallbackPartition
        CallbackPartition? partition = partitions[partitionIndex];
        if (partition == null)
        {
            //初始化CallbackPartition實(shí)例
            partition = new CallbackPartition(this);
            //如果partitions的partitionIndex下標(biāo)位置為null則使用partition填充
            partition = Interlocked.CompareExchange(ref partitions[partitionIndex], partition, null) ?? partition;
        }

        long id;
        CallbackNode? node;
        bool lockTaken = false;
        //鎖住操作
        partition.Lock.Enter(ref lockTaken);
        try
        {
            id = partition.NextAvailableId++;
            //獲取CallbackNode，這事真正存儲(chǔ)回調(diào)的地方，不要被List名字迷惑，其實(shí)是要構(gòu)建鏈表
            node = partition.FreeNodeList;
            if (node != null)
            {
                //這個(gè)比較有意思如果CallbackNode不是首次，則把最新的賦值給FreeNodeList
                partition.FreeNodeList = node.Next;
            }
            else
            {
                //首次的時(shí)候初始化一個(gè)CallbackNode實(shí)例
                node = new CallbackNode(partition);
            }
            node.Id = id;
            //Register的回調(diào)操作賦值給了CallbackNode的Callback
            node.Callback = callback;
            node.CallbackState = stateForCallback;
            node.ExecutionContext = executionContext;
            node.SynchronizationContext = syncContext;

            //構(gòu)建一個(gè)CallbackNode鏈表，從下面的代碼可以看出來構(gòu)建的其實(shí)是倒序鏈表，最新的CallbackNode是表頭
            node.Next = partition.Callbacks;
            if (node.Next != null)
            {
                node.Next.Prev = node;
            }
            //Callbacks記錄的是當(dāng)前的節(jié)點(diǎn)，如果下一次進(jìn)來新節(jié)點(diǎn)則作為新節(jié)點(diǎn)的Next節(jié)點(diǎn)
            partition.Callbacks = node;
        }
        finally
        {
            //釋放鎖
            partition.Lock.Exit(useMemoryBarrier: false); 
        }
        //用當(dāng)前注冊(cè)回調(diào)生成的CallbackNode節(jié)點(diǎn)生成CancellationTokenRegistration實(shí)例
        var ctr = new CancellationTokenRegistration(id, node);
        //如果未被取消則直接返回
        if (!IsCancellationRequested || !partition.Unregister(id, node))
        {
            return ctr;
        }
    }
    //走到這里說明IsCancellationRequested已經(jīng)等于true了也就是被取消了，則直接執(zhí)行該回調(diào)
    callback(stateForCallback);
    return default;
}

internal sealed class CallbackPartition
{
    public readonly CancellationTokenSource Source;
    //使用了自旋鎖
    public SpinLock Lock = new SpinLock(enableThreadOwnerTracking: false);
    public CallbackNode? Callbacks;
    public CallbackNode? FreeNodeList;
    public long NextAvailableId = 1; 

    public CallbackPartition(CancellationTokenSource source)
    {
        Source = source;
    }

    internal bool Unregister(long id, CallbackNode node)
    {
        //這里面有內(nèi)容,就不羅列了，判斷CallbackNode是否被取消注冊(cè)，如果為false說明未被取消注冊(cè)
    }
}

internal sealed class CallbackNode
{
    public readonly CallbackPartition Partition;
    //構(gòu)建鏈表的核心Prev和Next
    public CallbackNode? Prev;
    public CallbackNode? Next;

    public long Id;
    //回調(diào)操作被這個(gè)委托記錄
    public Action<object?>? Callback;
    public object? CallbackState;
    public ExecutionContext? ExecutionContext;
    public SynchronizationContext? SynchronizationContext;

    public CallbackNode(CallbackPartition partition)
    {
        Partition = partition;
    }

    public void ExecuteCallback()
    {
        //這里也有代碼，暫時(shí)不列出來，講取消的時(shí)候單獨(dú)講解
    }
}

public void Cancel() => Cancel(false);

public void Cancel(bool throwOnFirstException)
{
    ThrowIfDisposed();
    NotifyCancellation(throwOnFirstException);
}

private volatile int _threadIDExecutingCallbacks = -1;
private volatile CallbackPartition?[]? _callbackPartitions;
private const int NotifyingCompleteState = 3;
private void ExecuteCallbackHandlers(bool throwOnFirstException)
{
    //獲取當(dāng)前線程ID
    ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId;
    //將_callbackPartitions置為null，但是partitions不為null，因?yàn)镋xchange返回的是改變之前的值
    CallbackPartition?[]? partitions = Interlocked.Exchange(ref _callbackPartitions, null);
    //如果partitions為null說明是回調(diào)已經(jīng)通知完成狀態(tài)了直接返回
    if (partitions == null)
    {
        Interlocked.Exchange(ref _state, NotifyingCompleteState);
        return;
    }

    List<Exception>? exceptionList = null;
    try
    {
        //遍歷CallbackPartition數(shù)組
        foreach (CallbackPartition? partition in partitions)
        {
            //CallbackPartition實(shí)例為null說明這個(gè)分區(qū)未被使用直接跳過
            if (partition == null)
            {
                continue;
            }

            //循環(huán)處理CallbackNode鏈表
            while (true)
            {
                CallbackNode? node;
                bool lockTaken = false;
                //鎖住當(dāng)前操作
                partition.Lock.Enter(ref lockTaken);
                try
                {
                    //獲取鏈表的節(jié)點(diǎn)
                    node = partition.Callbacks;
                    //為null說明沒Register過直接中斷
                    if (node == null)
                    {
                        break;
                    }
                    else
                    {
                        //如果鏈表遍歷不是尾節(jié)點(diǎn),切斷和下一個(gè)節(jié)點(diǎn)的關(guān)聯(lián)
                        if (node.Next != null) node.Next.Prev = null;
                        //把下一個(gè)節(jié)點(diǎn)賦值給Callbacks
                        partition.Callbacks = node.Next;
                    }
                    //當(dāng)前執(zhí)行節(jié)點(diǎn)ID
                    _executingCallbackId = node.Id;
                    node.Id = 0;
                }
                finally
                {
                    //退出鎖
                    partition.Lock.Exit(useMemoryBarrier: false); 
                }

                try
                {
                    //如果當(dāng)時(shí)傳遞了同步上下文則直接在當(dāng)時(shí)的上下文調(diào)用ExecuteCallback委托
                    if (node.SynchronizationContext != null)
                    {
                        node.SynchronizationContext.Send(static s =>
                        {
                            var n = (CallbackNode)s!;
                            n.Partition.Source.ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId;
                            n.ExecuteCallback();
                        }, node);
                        ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId; 
                    }
                    else
                    {
                        //如果沒有傳遞SynchronizationContext則直接調(diào)用ExecuteCallback委托
                        //即調(diào)用Register的注冊(cè)的委托
                        node.ExecuteCallback();
                    }
                }
                catch (Exception ex) when (!throwOnFirstException)
                {
                    (exceptionList ??= new List<Exception>()).Add(ex);
                }
            }
        }
    }
    finally
    {
        //將全局狀態(tài)置為通知完成狀態(tài)
        //即已經(jīng)調(diào)用過Register回調(diào)
        _state = NotifyingCompleteState;
        Volatile.Write(ref _executingCallbackId, 0);
        Interlocked.MemoryBarrier(); 
    }

    //如果中途存在異常則拋出
    if (exceptionList != null)
    {
        Debug.Assert(exceptionList.Count > 0, $"Expected {exceptionList.Count} > 0");
        throw new AggregateException(exceptionList);
    }
}

public ExecutionContext? ExecutionContext;
public void ExecuteCallback()
{
    ExecutionContext? context = ExecutionContext;
    //如果Register的時(shí)候允許傳遞ExecutionContext則直接用這個(gè)上下文執(zhí)行回調(diào)Callback
    //Callback委托也就是承載Register的委托操作
    if (context != null)
    {
        ExecutionContext.RunInternal(context, static s =>
        {
            Debug.Assert(s is CallbackNode, $"Expected {typeof(CallbackNode)}, got {s}");
            CallbackNode n = (CallbackNode)s;

            Debug.Assert(n.Callback != null);
            n.Callback(n.CallbackState);
        }, this);
    }
    else
    {
        Debug.Assert(Callback != null);
        //直接在當(dāng)前線程調(diào)用Callback
        //Callback委托也就是承載Register的委托操作
        Callback(CallbackState);
    }
}

public void CancelAfter(TimeSpan delay)
{
    long totalMilliseconds = (long)delay.TotalMilliseconds;
    if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
    {
        throw new ArgumentOutOfRangeException(nameof(delay));
    }
    //調(diào)用的是重載的CancelAfter方法
    CancelAfter((int)totalMilliseconds);
}

private static readonly TimerCallback s_timerCallback = obj =>
{
    ((CancellationTokenSource)obj).NotifyCancellation(throwOnFirstException: false); 
};

public void CancelAfter(int millisecondsDelay)
{
    //傳遞的毫秒數(shù)不能小于-1
    if (millisecondsDelay < -1)
    {
        throw new ArgumentOutOfRangeException(nameof(millisecondsDelay));
    }

    //如果已經(jīng)取消則直接返回
    if (IsCancellationRequested)
    {
        return;
    }

    //注冊(cè)一個(gè)定時(shí)器執(zhí)行s_timerCallback
    //s_timerCallback在上面我們介紹過了 本這就是調(diào)用CancellationTokenSource的NotifyCancellation方法
    TimerQueueTimer? timer = _timer;
    if (timer == null)
    {
        timer = new TimerQueueTimer(s_timerCallback, this, Timeout.UnsignedInfinite, Timeout.UnsignedInfinite, flowExecutionContext: false);
        TimerQueueTimer? currentTimer = Interlocked.CompareExchange(ref _timer, timer, null);
        if (currentTimer != null)
        {
            timer.Close();
            timer = currentTimer;
        }
    }

    try
    {
        timer.Change((uint)millisecondsDelay, Timeout.UnsignedInfinite);
    }
    catch (ObjectDisposedException)
    {
    }
}