c#Task任务学习记录

  static CancellationTokenSource tokenSource = new CancellationTokenSource();
        CancellationToken token = tokenSource.Token;
        ManualResetEvent resetEvent = new ManualResetEvent(true);
        public Form1()
        {
            InitializeComponent();
        }

        private async void button1_Click(object sender, EventArgs e)
        {
            #region 异步 暂停 继续 取消 结束回调 （不阻塞界面）
            Task task = new Task(async () =>
            {
                while (true)
                {
                    if (token.IsCancellationRequested)//是否取消线程
                    {
                        return;
                    }
                    resetEvent.WaitOne();//是否阻塞线程

                    Test();
                    Console.WriteLine("加法之后的输出！！！");
                    // 模拟等待100ms
                    await Task.Delay(100);
                }
            }, token, TaskCreationOptions.None);
            task.Start();
            //异步等待返回，不阻塞界面
            await task.ContinueWith( (t) =>
            {
                //获取线程返回
                Console.WriteLine("任务完成回调，完成时候的状态为：");
                Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
            });
            #endregion

            #region 任务返回值，长时间运行任务，任务等待完成（阻塞界面不能拖动）
            //带返回值的不能用async，不使用 async 阻塞界面
            //Task<int> task = new Task<int>(() =>
            //{
            //    while (true)
            //    {
            //        if (token.IsCancellationRequested)//是否取消线程
            //        {
            //            return 1;
            //        }
            //        resetEvent.WaitOne();//是否阻塞线程

            //        Test();
            //        Console.WriteLine("加法之后的输出！！！");
            //        // 模拟等待100ms
            //        return 2;
            //    }     //标记为长时间运行任务,则任务不会使用线程池,而在单独的线程中运行。 
            //}, token, TaskCreationOptions.LongRunning);
            //task.Start();
            //task.ContinueWith((t) =>
            //{
            //    //获取线程返回
            //    Console.WriteLine("任务完成回调，完成时候的状态为：");
            //    Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
            //});
            //task.Wait();//等待任务完成
            //Console.WriteLine("任务完成，返回值" + task.Result);
            #endregion

            #region 设置在主线程运行，阻塞界面
            ////
            //Task task = new Task(async () =>
            //{
            //    while (true)
            //    {
            //        if (token.IsCancellationRequested)//是否取消线程
            //        {
            //            return ;
            //        }
            //        resetEvent.WaitOne();//是否阻塞线程

            //        Test();
            //        Console.WriteLine("加法之后的输出！！！");
            //        await Task.Delay(1);
            //    }     //标记为长时间运行任务,则任务不会使用线程池,而在单独的线程中运行。 
            //}, token, TaskCreationOptions.LongRunning);

            ////task.RunSynchronously();//设置在主线程运行，阻塞界面
            //task.Start();
            #endregion

            #region 任务串行，并行
            //task1先串行
            //Task task1 = Task.Factory.StartNew(async () =>
            //{
            //    Test(1);
            //    Test(2);
            //    await Task.Delay(100);
            //});

            ////t2,t3并行执行
            //Task t2 = task1.ContinueWith(async t =>
            //{
            //    Test(3);
            //    Console.WriteLine("Task t2 result={0},Thread id {1}", task1.IsCompleted, Thread.CurrentThread.ManagedThreadId);
            //    await Task.Delay(100);
            //});

            ////t2,t3并行执行
            //Task t3 = task1.ContinueWith(async t =>
            //{
            //    Test(4);
            //    Console.WriteLine("Task t3 result={0},Thread id {1}", task1.IsCompleted, Thread.CurrentThread.ManagedThreadId);
            //    await Task.Delay(100);
            //});
            ////等待t2和t3执行完
            //Task.WaitAll(t2, t3);
            ////t7串行执行
            //var t4 = Task.Factory.StartNew(() =>
            //{
            //    Console.WriteLine("当前集合元素个数：{0},Thread id {1}", task1.IsCompleted, Thread.CurrentThread.ManagedThreadId);
            //});
            //t4.Wait();
            #endregion

            #region 任务中的异常

            //try
            //{
            //    Task task = new Task(async () =>
            //    {
            //        while (true)
            //        {
            //            if (token.IsCancellationRequested)//是否取消线程
            //            {
            //                return;
            //            }
            //            resetEvent.WaitOne();//是否阻塞线程

            //            TestException(1);
            //            Console.WriteLine("加法之后的输出！！！");
            //            await Task.Delay(1);
            //        }     //标记为长时间运行任务,则任务不会使用线程池,而在单独的线程中运行。 
            //    }, token, TaskCreationOptions.LongRunning);
            //    task.Start();
            //}
            //catch (Exception ex)
            //{

            //    throw;
            //}

            //task.RunSynchronously();//设置在主线程运行，阻塞界面

            #endregion

            #region 更新进度条
            //当前线程
            //var progress = new Progress<int>(percent =>
            //{
            //    Console.Clear();
            //    Console.Write("{0}%", percent);
            //});
            ////线程池线程
            ////Task.Run(async () => DoProcessing(progress));//界面拖动卡顿
            //await Task.Run(() => DoProcessing(progress));//界面拖动卡顿
            //Console.WriteLine("");
            //Console.WriteLine("结束");
            #endregion

            #region 设置线程优先级
            //TaskScheduler scheduler = TaskScheduler.FromCurrentSynchronizationContext();
            ////
            //var task = new Task(async () =>
            //{
            //    //设置线程优先级
            //    Thread.CurrentThread.Priority = ThreadPriority.Lowest;
            //    while (true)
            //    {
            //        if (token.IsCancellationRequested)//是否取消线程
            //        {
            //            return;
            //        }
            //        resetEvent.WaitOne();//是否阻塞线程

            //        for (int g = 0; g < 20; g++)
            //        {
            //            label1.Text = "测试Id:" + g;
            //            Console.WriteLine("测试Id:" + g);
            //            Thread.Sleep(1000);
            //        }

            //        Test();
            //        Console.WriteLine("加法之后的输出！！！");
            //        await Task.Delay(1);
            //    }     //标记为长时间运行任务,则任务不会使用线程池,而在单独的线程中运行。 
            //}, CancellationToken.None, TaskCreationOptions.None);

            ////task.RunSynchronously();//设置在主线程运行，阻塞界面
            //task.Start();


            #endregion
        }
        private void Test()
        {
            int a = 0;
            for (int i = 0; i < 20; i++)
            {
                resetEvent.WaitOne();//是否阻塞线程
                Thread.Sleep(2000);
                a = a += 1;
                Console.WriteLine($"测试加法{a}");
                if (token.IsCancellationRequested)//线程是否取消
                {
                    return;
                }
            }
        }
        private void Test(int Rows)
        {
            Console.WriteLine("任务执行" + Rows);
            int a = 0;
            for (int i = 0; i < 20; i++)
            {
                resetEvent.WaitOne();//是否阻塞线程
                Thread.Sleep(2000);
                a = a += 1;
                Console.WriteLine($"测试加法{a}");
                if (token.IsCancellationRequested)//线程是否取消
                {
                    return;
                }
            }
        }
        private void TestException(int Rows)
        {
            Console.WriteLine("任务执行" + Rows);
            int a = 0;
            for (int i = 0; i < 20; i++)
            {
                resetEvent.WaitOne();//是否阻塞线程
                Thread.Sleep(2000);
                a = a += 1;
                Console.WriteLine($"测试加法{a}");
                if (token.IsCancellationRequested)//线程是否取消
                {
                    return;
                }
            }
            throw new Exception("Boom!");
        }

         void DoProcessing(IProgress<int> progress)
        {
            for (int i = 0; i <= 100; ++i)
            {
                Thread.Sleep(100);
                if (progress != null)
                {
                    progress.Report(i);
                }
            }
        }

         async Task Display()
        {
            //当前线程
            var progress = new Progress<int>(percent =>
            {
                Console.Clear();
                Console.Write("{0}%", percent);
            });
            //线程池线程
            await Task.Run(() => DoProcessing(progress));
            Console.WriteLine("");
            Console.WriteLine("结束");
        }


        private void Button_Click_1(object sender, EventArgs e)
        {
            Console.WriteLine("点击暂停");
            resetEvent.Reset();//暂停Task
        }

        private void Button_Click_2(object sender, EventArgs e)
        {
            Console.WriteLine("点击继续");
            resetEvent.Set();//继续
        }

        private void Button_Click_3(object sender, EventArgs e)
        {
            Console.WriteLine("点击取消");
            tokenSource.Cancel();//取消
        }