第五节：Task构造函数之TaskCreationOptions枚举处理父子线程之间的关系。

一. 整体说明

揭秘：

　　通过F12查看Task类的源码(详见下面的截图)，发现Task类的构造函数有有一个参数为：TaskCreationOptions类型，本章节可以算作是一个扩展章节，主要就来研究TaskCreationOptions类的作用。

　　该类主要用来处理父子线程之间的关系，重要的几个参数如下：　

　　①.AttachedToParent:指定将任务附加到任务层次结构中的某个父级,父任务必须等待所有子任务执行完毕才能执行

　　　　（下面的例子task线程必须等task1和task2线程执行完毕才能执行）

　　②. DenyChildAttach: 不允许子任务附加到父任务上

　　　　(下面例子task不再等待task1和task2,和00的默认效果相同)

　　③. HideScheduler： 子任务不使用父类Task的Scheduler，而是使用默认的 (不进行测试)

　　④. LongRunning：当已知是长时间运行的任务，可以使用该选项 (不进行测试)

　　⑤. PreferFairness：类似于队列的感觉，尽可能公平的方式安排任务 (不进行测试)

 源码如下：

 // 摘要: 
    //     指定可控制任务的创建和执行的可选行为的标志。
    [Serializable]
    [Flags]
    public enum TaskCreationOptions
    {
        // 摘要: 
        //     指定应使用默认行为。
        None = 0,
        //
        // 摘要: 
        //     提示 System.Threading.Tasks.TaskScheduler 以一种尽可能公平的方式安排任务，这意味着较早安排的任务将更可能较早运行，而较晚安排运行的任务将更可能较晚运行。
        PreferFairness = 1,
        //
        // 摘要: 
        //     指定某个任务将是运行时间长、粗粒度的操作。 它会向 System.Threading.Tasks.TaskScheduler 提示，过度订阅可能是合理的。
        LongRunning = 2,
        //
        // 摘要: 
        //     指定将任务附加到任务层次结构中的某个父级。
        AttachedToParent = 4,
        //
        // 摘要: 
        //     如果尝试附有子任务到创建的任务，指定 System.InvalidOperationException 将被引发。
        DenyChildAttach = 8,
        //
        // 摘要: 
        //     防止环境计划程序被视为已创建任务的当前计划程序。 这意味着像 StartNew 或 ContinueWith 创建任务的执行操作将被视为 System.Threading.Tasks.TaskScheduler.Default
        //     当前计划程序。
        HideScheduler = 16,
    }

二. 实际测试

 　　这里我们主要通过代码来比较默认情况下、AttachedToParent、DenyChildAttach之间的效果， task线程内部有task1和task2线程，并且在task内部开启。

1. 默认情况

        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            Console.WriteLine("----------------- Task多线程测试  --------------------------");
            Console.WriteLine("----------------- button1_Click 开始 主线程id为：{0}  --------------------------", Thread.CurrentThread.ManagedThreadId);

            #region 00-默认
            {
                Task task = new Task(() =>
                {
                    Task task1 = new Task(() =>
                    {
                        Thread.Sleep(1000);
                        Console.WriteLine("我是task1线程");
                    });
                    Task task2 = new Task(() =>
                    {
                        Thread.Sleep(1000);
                        Console.WriteLine("我是task2线程");
                    });

                    task1.Start();
                    task2.Start();
                });

                task.Start();
                task.Wait();   //单个线程的等待
                Console.WriteLine("------------------我是主线程--------------------");
            }
            #endregion

            watch.Stop();
            Console.WriteLine("----------------- button1_Click 结束 主线程id为：{0}  总耗时：{1}--------------------------", Thread.CurrentThread.ManagedThreadId, watch.ElapsedMilliseconds);
        }

　　多次执行上述代码看效果：发现task线程执行完后，task1和task2才无序的执行。

2. AttachedToParent

　　作用：指定将任务附加到任务层次结构中的某个父级,父任务必须等待所有子任务执行完毕才能执行

         {
                Task task = new Task(() =>
                {
                    Task task1 = new Task(() =>
                    {
                        Thread.Sleep(3000);
                        Console.WriteLine("我是task1线程");
                    }, TaskCreationOptions.AttachedToParent);
                    Task task2 = new Task(() =>
                    {
                        Thread.Sleep(3000);
                        Console.WriteLine("我是task2线程");
                    }, TaskCreationOptions.AttachedToParent);

                    task1.Start();
                    task2.Start();
                });

                task.Start();
                task.Wait();   //单个线程的等待
                Console.WriteLine("------------------我是主线程--------------------");
            }

 　　多次执行上述代码看效果：发现task线程必须等task1和task2执行完毕后才能执行（印证了AttachedToParent的作用），task1和task2无先后顺序。

3. DenyChildAttach

 　　作用：不允许子任务附加到父任务上。

 {
                Task task = new Task(() =>
                {
                    Task task1 = new Task(() =>
                    {
                        Thread.Sleep(3000);
                        Console.WriteLine("我是task1线程");
                    }, TaskCreationOptions.AttachedToParent);
                    Task task2 = new Task(() =>
                    {
                        Thread.Sleep(3000);
                        Console.WriteLine("我是task2线程");
                    }, TaskCreationOptions.AttachedToParent);

                    task1.Start();
                    task2.Start();
                }, TaskCreationOptions.DenyChildAttach);

                task.Start();
                task.Wait();   //单个线程的等待
                Console.WriteLine("------------------我是主线程--------------------");
            }

 多次执行上述代码看效果：发现task线程执行完后，task1和task2才无序的执行。（和上述的默认情况是一致的）