多线程的几种方式

        /// <summary>
        /// 简单的利用线程此启动线程
        /// </summary>
        public static void NewMethod1()
        {
            //只需要方法需要执行的方法就会启动线程池的的一个线程,不需要显示启动
            ThreadPool.UnsafeQueueUserWorkItem(new ThreadTest2().Task, 55);

            Debug.WriteLine(Thread.CurrentThread.ManagedThreadId + " Main: " + name);

        }

        public void Task(Object obj)
        {
            Debug.WriteLine(Thread.CurrentThread.ManagedThreadId + " Thread: " + obj + name);
        }

public static void NewMethod2()
        {
            //在初始线程中设置逻辑调用上下文数据,会流向辅助线程
            CallContext.LogicalSetData("Name", "Jeffrey");

            ThreadPool.QueueUserWorkItem(statue =>
            {
                //从辅助线程中确实拿到了数据上下文的数据
                Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name"));
            });

            //取消执行上下文在异步线程之间的流动。
            ExecutionContext.SuppressFlow();

            ThreadPool.QueueUserWorkItem(statue =>
            {
                Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name"));
            });

            //恢复执行上下文在异步线程之间的流动。
            ExecutionContext.RestoreFlow();
            Console.ReadKey();
        }

/// <summary>
        /// 协作是取消,支持在初始线程中中断辅助线程的生命
        /// </summary>
        public static void NewMethod3()
        {
            // 这个类就是控制辅助线程的终止的
            CancellationTokenSource cts = new CancellationTokenSource();

            ThreadPool.QueueUserWorkItem(o => Count(cts.Token, 100)); //这里传递了一个参数过去

            Debug.WriteLine("this");
            Thread.Sleep(1000);
            //通过调用这个方法来终止辅助线程的生命
            cts.Cancel();
        }

        private static void Count(CancellationToken token, int countTo)
        {
            for (Int32 count = 0; count < countTo; count++)
            {
                //通过这个判断在初始线程中是否终止了改线程的生命
                if (token.IsCancellationRequested)
                {
                    Debug.WriteLine("Count is cancelled");
                    break;
                }

                Debug.WriteLine(count);
                Thread.Sleep(100);
            }
            Debug.WriteLine("Count is done");

        }


        /// <summary>
        /// 可以为辅助线程停止定义回调方法
        /// </summary>
        public static void NewMethod31()
        {
            var cts1 = new CancellationTokenSource();
            //为cts1 注册一个辅助线程停止的回调方法
            cts1.Token.Register(() => { Debug.WriteLine("this 1"); });


            var cts2 = new CancellationTokenSource();
            //为cts2 注册一个辅助线程停止的回调方法
            ThreadPool.QueueUserWorkItem(o => { Count(cts2.Token, 10); });
            cts2.Token.Register(() => { Debug.WriteLine("this 2"); });

            //为cts1 或 cts2 注册一个辅助线程停止的回调方法
            var cts3 = CancellationTokenSource.CreateLinkedTokenSource(cts1.Token, cts2.Token);
            cts3.Token.Register(() => { Debug.WriteLine("this 3"); });

            cts2.Cancel();

            Debug.WriteLine("cts1: " + cts1.IsCancellationRequested + " cts2: " + cts2.IsCancellationRequested + " cts3: " + cts3.IsCancellationRequested);

        }

 public static void NewMethod4()
        {
            // Task接受一个带返回值的delegate 
            Task<Int32> t = new Task<Int32>((n => Sum((Int32)n)), 10000);
            //将任务放置到线程队列当中
            t.Start();
            //t.Wait();
            //Console.WriteLine(t.Result);
            //这种方式不会造成堵塞,在Task执行完毕的时候,就会启动这个任务
            t.ContinueWith(task => { Console.WriteLine(t.Result); });
            Console.WriteLine("this");
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; n--)
            {
                checked { sum += n; };
            }
            return sum;
        }

/// <summary>
        /// 支持协作式的 Task操作
        /// </summary>
        public static void NewMethod41()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            Task<Int32> t = new Task<Int32>((() => Sum(cts.Token, 10000)), cts.Token);
            t.Start();
            cts.Cancel();

            try
            {
                Debug.WriteLine(t.Result);
            }
            catch (AggregateException x)
            {
                x.Handle(e => e is OperationCanceledException);
                Debug.WriteLine("Exception");
            }

        }

        private static int Sum(CancellationToken ct, int n)
        {
            int sum = 0;
            for (; n > 0; n--)
            {
                ct.ThrowIfCancellationRequested();
                checked { sum += n; };
            }
            return sum;
        }

/// <summary> 
        ///  添加子Task
        /// </summary>
        public static void NewMethod42()
        {
            Task<Int32[]> parent = new Task<Int32[]>(() =>
            {
                var results = new Int32[3];
                Task task1 = new Task(() => results[0] = Sum(10000), TaskCreationOptions.AttachedToParent);
                task1.Start();
                Task task2 = new Task(() => results[1] = Sum(10000), TaskCreationOptions.AttachedToParent);
                task2.Start();
                Task task3 = new Task(() => results[2] = Sum(10000), TaskCreationOptions.AttachedToParent);
                task3.Start();
                Console.WriteLine(task1.Id);
                Console.WriteLine("Thread status: " + task1.Status);
                Console.WriteLine(task2.Id);
                Console.WriteLine(task3.Id);

                return results;
            });
            Console.WriteLine("parent: " + parent.Id);
            Console.WriteLine("parent status" + parent.Status);
            var cwt = parent.ContinueWith(parentTask => Array.ForEach(parentTask.Result, Console.WriteLine));
            parent.Start();
            Console.WriteLine("parent status" + parent.Status);
            Console.ReadKey();
        }

/// <summary>
        /// TaskFactory 
        /// </summary>
        public static void NewMethod43()
        {
            Task parent = new Task(() =>
            {
                var cts = new CancellationTokenSource();
                var tf = new TaskFactory<Int32>(cts.Token, TaskCreationOptions.AttachedToParent,
                    TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

                var childTasks = new[]
                {
                  tf.StartNew(()=>Sum(cts.Token, 10000)),
                  tf.StartNew(()=>Sum(cts.Token, 20000)),  
                  tf.StartNew(()=>Sum(cts.Token, Int32.MaxValue))  
                };

                for (Int32 task = 0; task < childTasks.Length; task++)
                {
                    childTasks[task].ContinueWith(t => cts.Cancel(), TaskContinuationOptions.OnlyOnFaulted);
                }

                tf.ContinueWhenAll(
                    childTasks,
                    completedTasks => completedTasks.Where(t => !t.IsFaulted && !t.IsCanceled).Max(t => t.Result),
                    CancellationToken.None
                    ).ContinueWith(
                        t => Console.WriteLine(t.Result),
                        TaskContinuationOptions.ExecuteSynchronously
                    );

            });
            parent.ContinueWith(p =>
            {
                StringBuilder sb = new StringBuilder(Environment.NewLine);
                foreach (var e in p.Exception.Flatten().InnerExceptions)
                    sb.Append(e.GetType().ToString());
                Debug.WriteLine(sb.ToString());

            }, TaskContinuationOptions.OnlyOnFaulted);

            parent.Start();
        }