c# task笔记

    class Program
    {
        //创建Task任务的三种方式（无返回值）
        static void Main(string[] args)
        {
            //方法一
            Task task1 = new Task(() =>
            {
                Console.WriteLine("方法一异步任务");
                Thread.Sleep(2000);

            });
            task1.Start();
            Task.WaitAll(task1);
            //方法二
            Task.Run(() =>
            {
                Console.WriteLine("方法二异步任务");
            });
            //方法三
            Task.Factory.StartNew(() =>
            {
                Console.WriteLine("方法三：通过工厂创建异步任务对象");
            });
            Console.ReadLine();
        }
    }

        //创建Task任务的三种方式（无返回值）
        static void Main(string[] args)
        {
            var t1 = new Task(() => TaskMethod("task1"));
            var t2 = new Task(() => TaskMethod("task2"));
            t1.Start();
            t2.Start();
            Task.WaitAll(t1, t2);
            Task.Run(() => TaskMethod("task3"));
            Task.Factory.StartNew(() => TaskMethod("task4"));
            Task.Factory.StartNew(() => TaskMethod("task5"), TaskCreationOptions.LongRunning);
            Console.WriteLine("主线程开始执行任务");
            Task task = new Task(() =>
            {
                Console.WriteLine("使用System.Threading.Tasks.Task执行异步操作.");
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine(i);
                }
            });
            task.Start();
            Console.WriteLine("主线程执行其他任务");
            task.Wait();

            Console.ReadLine();
        }
        static void TaskMethod(string taskName)
        {
            Console.WriteLine($"任务名称：{taskName}，线程Id：{Thread.CurrentThread.ManagedThreadId},是否为线程池执行：{Thread.CurrentThread.IsThreadPoolThread}");
        }

        /// <summary>
        /// 带返回值的Task<int>案例代码
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            TaskMethod("main task");
            Task<int> task = CreateTask("task1");
            task.Start();
            int result = task.Result;
            Console.WriteLine("task1 result is :" + result);

            task =CreateTask("task2");
            task.RunSynchronously();//在当前主线程中同步执行task
            result = task.Result;
            Console.WriteLine("task2 result is :" + result);
            

            task = CreateTask("task3");
            Console.WriteLine(task.Status);
            task.Start();
            while (!task.IsCompleted)
            {
                Console.WriteLine(task.Status);
                Thread.Sleep(1000);
            }

            //常规使用方法
            task = new Task<int>(() => Getsum());
            task.Start();
            Console.WriteLine("主线程执行其他任务");
            task.Wait();
            Console.WriteLine("获取task执行结果" + task.Result.ToString());
            Console.ReadLine();

        }
        static Task<int> CreateTask(string name)
        {
            return new Task<int>(() => TaskMethod(name));
        }
        static int TaskMethod(string name)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
                name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
            Thread.Sleep(TimeSpan.FromSeconds(2));
            return 42;
        }
        static int Getsum()
        {
            int sum = 0;
            Console.WriteLine("使用Task执行异步操作.");
            for (int i = 0; i < 100; i++)
            {
                sum += i;
            }
            return sum;
        }

        /// <summary>
        ///  async/await实现带返回值task
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            
            Task<int> task = AsyncMethod();
            Console.WriteLine("主线程执行其他处理,线程id:"+Thread.CurrentThread.ManagedThreadId);
            for (int i = 1; i <= 3; i++)
                Console.WriteLine("Call Main()");
            int result = task.Result;//阻塞主线程
            Console.WriteLine("任务执行结果：{0}", result);
            Console.ReadLine();
        }
        async static Task<int> AsyncMethod()
        {
            Console.WriteLine("使用Task执行异步操作.线程id:" + Thread.CurrentThread.ManagedThreadId);
            await Task.Delay(1000);
            int sum = 0;
            Console.WriteLine("使用Task执行异步操作.线程id:"+Thread.CurrentThread.ManagedThreadId);
            for (int i = 0; i < 100; i++)
            {
                sum += i;
            }
            return sum;
        }

        /// <summary>
        ///  并行任务
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            ConcurrentStack<int> stack = new ConcurrentStack<int>();
            var t1 = new Task(() =>
            {
                stack.Push(1);
                stack.Push(2);
            });
            t1.Start();
            Console.WriteLine(DateTime.Now.ToString());
            //t2 t3并行执行
            var t2 = t1.ContinueWith((task) =>
            {
                int result;
                stack.TryPop(out result);
                Console.WriteLine("Task t2  pop result={0},Thread id {1}", result, Thread.CurrentThread.ManagedThreadId);
            });
            //t2,t3并行执行
            var t3 = t1.ContinueWith(t =>
            {
                int result;
                stack.TryPop(out result);
                Console.WriteLine("Task t3  pop result={0},Thread id {1}", result, Thread.CurrentThread.ManagedThreadId);
            });
            Task.WaitAll(t2, t3);
            //t4串行执行
            var t4 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("当前集合元素个数：{0},Thread id {1}", stack.Count, Thread.CurrentThread.ManagedThreadId);
            });
            t4.Wait();
            Console.ReadLine();
        }

        /// <summary>
        ///  子任务
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Task<string[]> parent = new Task<string[]>(() =>
            {
                string[] array = new string[2];
                new Task(() => { array[0] = "result1";Thread.Sleep(2000); }, TaskCreationOptions.AttachedToParent).Start();
                new Task(() => { array[1] = "result2"; Thread.Sleep(2000); }, TaskCreationOptions.AttachedToParent).Start();
                return array;
            });
            parent.ContinueWith((task) =>
            {
                foreach(string str in task.Result)
                {
                    Console.WriteLine("结果：" + str);
                }

            });
            parent.Start();
            Console.WriteLine("主线程");
            parent.Wait();//wait只能等到父Task结束，不能等到父线程的ContinueWith结束
            Console.WriteLine("主线程");
            Console.ReadLine();
        }

        /// <summary>
        ///  取消任务
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            var cts = new CancellationTokenSource();
            var task = new Task<int>(() => TaskMethod("task 1", 10, cts.Token), cts.Token);
            Console.WriteLine(task.Status);
            Console.ReadLine();
            cts.Cancel();
            Console.WriteLine(task.Status);
            Console.WriteLine("task1已经被取消！");
            cts = new CancellationTokenSource();
            task = new Task<int>(() => TaskMethod("task2 ", 10, cts.Token), cts.Token);
            task.Start();
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine(task.Status);
            }
            cts.Cancel();
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine(task.Status);
            }
            Console.ReadLine();
        }
        static int TaskMethod(string name, int seconds, CancellationToken token)
        {
            Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
    name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
            for(int i = 0; i < seconds; i++)
            {
                Thread.Sleep(500);
                if (token.IsCancellationRequested)
                {
                    return -1;
                }
            }
            return 42 * seconds;
        }