创建CancellationTokenSource对象用于取消Task

时间：2022-01-28 20:36:02

　　虽然使用线程池ThreadPool让我们使用多线程变得容易，但是因为是由系统来分配的，如果想对线程做精细的控制就不太容易了，比如某个线程结束后执行一个回调方法。恰好Task可以实现这样的需求。这篇文章我从以下几点对Task进行总结。

  1. 认识Task
  2. Task的用法

Task类在命名空间System.Threading.Tasks下，通过Task的Factory返回TaskFactory类，以TaskFactory.StartNew(Action)方法可以创建一个新的异步线程，所创建的线程默认为后台线程，不会影响前台UI窗口的运行。

如果要取消线程，可以利用CancellationTakenSource对象。如果要在取消任务后执行一个回调方法，则可以使用Task的()方法。

利用Task对之前的例子进行重写和扩展。代码如下。

namespace ThreadDemo

{

    class Program

    {

        static void Main(string[] args)

        {

            // 创建CancellationTokenSource对象用于取消Task

            CancellationTokenSource cancelTokenSource = new CancellationTokenSource();

            Fish fish1 = new Fish() { Name = "小黄鱼", Score =  };

            Fish fish2 = new Fish() { Name = "大鲨鱼", Score =  };

            // 创建一个Task

            Task task1 = new Task(() => fish1.Move(cancelTokenSource.Token), cancelTokenSource.Token);

            task1.Start();

            // Task1被取消后的回调方法(小黄鱼被击中后显示积分)

            task1.ContinueWith(fish1.ShowScore);

            Task task2 = new Task(() => fish2.Move(cancelTokenSource.Token), cancelTokenSource.Token);

            task2.Start();

            task2.ContinueWith(fish2.ShowScore);

            // 按任意键发射

            Console.ReadKey();

            // 武器工厂线程池

            Gun gun = new Gun();

            LaserGun laserGun = new LaserGun();

            TaskFactory taskFactory = new TaskFactory();

            Task[] tasks = new Task[]

            {

                taskFactory.StartNew(()=>gun.Fire()),

                taskFactory.StartNew(()=>laserGun.Fire())

            };

            // 执行武器开火

            taskFactory.ContinueWhenAll(tasks, (Task) => { });

            cancelTokenSource.Cancel();

            Console.ReadKey();

        }

    }

    /// <summary>

    /// 鱼

    /// </summary>

    public class Fish

    {

        public string Name { get; set; }

        public int Score { get; set; }

        public Fish()

        {

        }

        public void Move()

        {

            Console.WriteLine(string.Format("{0}在游来游去...", Name));

        }

        /// <summary>

        /// 游动

        /// </summary>

        /// <param name="cancelToken"></param>

        public void Move(CancellationToken cancelToken)

        {

            while (!cancelToken.IsCancellationRequested)

            {

                Console.WriteLine(string.Format("{0}在游来游去...", Name));

                // 阻塞1秒

                Thread.Sleep();

            }

        }

        /// <summary>

        /// 中枪后显示奖励

        /// </summary>

        /// <param name="task"></param>

        public void ShowScore(Task task)

        {

            Console.WriteLine(string.Format("{0}中弹了，你得到{1}分",Name,Score));

        }

    }

}

程序运行结果如下：

aaarticlea/png;base64,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" alt="" />

eg2:

C# 使用 CancellationTokenSource 终止线程

使用CancellationTokenSource对象需要与Task对象进行配合使用，Task会对当前运行的状态进行控制（这个不用我们关心是如何孔控制的）。而CancellationTokenSource则是外部对Task的控制，如取消、定时取消。

下面我们来看看示例代码

  1. class Program
  2. {
  3. //声明CancellationTokenSource对象
  4. static CancellationTokenSource cancelTokenSource = new CancellationTokenSource();
  5. //程序入口
  6. static void Main(string[] args)
  7. {
  8. Task.Factory.StartNew(MyTask, cancelTokenSource.Token);
  9. Console.WriteLine("请按回车键(Enter)停止");
  10. Console.ReadLine();
  11. cancelTokenSource.Cancel();
  12. Console.WriteLine("已停止");
  13. Console.ReadLine();
  14. }
  15. //测试方法
  16. static void MyTask()
  17. {
  18. //判断是否取消任务
  19. while (!cancelTokenSource.IsCancellationRequested)
  20. {
  21. Console.WriteLine(DateTime.Now);
  22. Thread.Sleep(1000);
  23. }
  24. }
  25. }

运行效果如图

创建CancellationTokenSource对象用于取消TaskTask.Factory.StartNew 创建并启动了 MyTask 方法，并传递了一个 CancellationTokenSource.Token 对象进去。我们可以通过在外部CancellationTokenSource对象进行控制是否取消任务的运行。

当在 MyTask 中的 cancelTokenSource.IsCancellationRequested 判断如果是取消了任务的话 就跳出while循环执行。也就结束了任务

我们还可以使用计时取消任务，当一个任务超过了我们所设定的时间然后自动取消该任务的执行。如下代码所示

  1. var cancelTokenSource = new CancellationTokenSource(3000);

除了构造函数，我们还可以使用另外一种方式实现定时取消，如下代码所示

  1. cancelTokenSource.CancelAfter(3000);

运行起来效果是一样的，3秒钟定时取消。

多个 CancellationTokenSource 复合

在有多个CancellationTokenSource需要一起并行管理的时候，比如任意一个任务取消 则取消所有任务。我们不必去一个一个的去关闭，只需要将需要一起并行关闭的CancellationTokenSource组合起来就行了。如下代码所示，执行结果是跟上面的图一样的。我就不再上图了。

  1. class Program
  2. {
  3. //声明CancellationTokenSource对象
  4. static CancellationTokenSource c1 = new CancellationTokenSource();
  5. static CancellationTokenSource c2 = new CancellationTokenSource();
  6. static CancellationTokenSource c3 = new CancellationTokenSource();
  7. //使用多个CancellationTokenSource进行复合管理
  8. static CancellationTokenSource compositeCancel = CancellationTokenSource.CreateLinkedTokenSource(c1.Token, c2.Token, c3.Token);
  9. //程序入口
  10. static void Main(string[] args)
  11. {
  12. Task.Factory.StartNew(MyTask, compositeCancel.Token);
  13. Console.WriteLine("请按回车键(Enter)停止");
  14. Console.ReadLine();
  15. //任意一个 CancellationTokenSource 取消任务，那么所有任务都会被取消。
  16. c1.Cancel();
  17. Console.WriteLine("已停止");
  18. Console.ReadLine();
  19. }
  20. //测试方法
  21. static void MyTask()
  22. {
  23. //判断是否取消任务
  24. while (!compositeCancel.IsCancellationRequested)
  25. {
  26. Console.WriteLine(DateTime.Now);
  27. Thread.Sleep(1000);
  28. }
  29. }
  30. }

以上代码调用了c1.Cancel();触发了MyTask()方法中的compositeCancel.IsCancellationRequested为true，则取消了任务。所以我们在所有任务中判断复合的这个CancellationTokenSource对象即可。

相关文章