.NET 实现并行的几种方式（一）

好久没有更新了，今天来一篇，算是《同步与异步》系列的开篇吧，加油，坚持下去（PS:越来越懒了）。

一、Thread

利用Thread 可以直接创建和控制线程，在我的认知里它是最古老的技术了。因为out了、所以不再写例子了。

二、ThreadPool

由于线程的创建和销毁需要耗费大量的资源，为了提过性能、引入了线程池、即ThreadPool，ThreadPool 可隐式完成线程的创建和分配管理工作。

以下是来自MSDN的几句备注：

　　线程池根据需要提供新的工作线程或 I/O 完成线程，直到其达到每个类别的最小值。 当达到最小值时，线程池可以在该类别中创建更多线程或等待某些任务完成。 从 .NET Framework 4 开始，线程池会创建和销毁工作线程以优化吞吐量，吞吐量定义为单位时间内完成的任务数。 线程过少时可能无法更好地利用可用资源，但线程过多时又可能会加剧资源的争用情况。

直接应用 ThreadPool时、有两种应用场景：

1、将需要异步执行的方法、排入队列，当有可用线程时执行被排入队列的方法

            // 该应用场景下 ThreadPool 提供如下两种形式的重载方法
            // public static bool QueueUserWorkItem(WaitCallback callBack);
            // public static bool QueueUserWorkItem(WaitCallback callBack, object state);

            // WaitCallback 为 delegate, 一个object类型的入参，没有返回值。
            // public delegate void WaitCallback(object state);

            base.SetTip(nameof(ThreadPool.QueueUserWorkItem));

            ThreadPool.QueueUserWorkItem((state) =>
            {
                this.SetTip("等待一秒");
                Thread.Sleep();
                this.SetTip("任务执行完毕");
            });

2、注册等待信号对象(WaitHandle)、并在其收到信号或超时时触发回调函数

            // 该应用场景下 ThreadPool 提供了四种形式的重载方法, 下面的重载形式在我看来是最具有直观意义的
            // public static RegisteredWaitHandle RegisterWaitForSingleObject(
            //      WaitHandle waitObject, WaitOrTimerCallback callBack, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce);

            // 其中 WaitHandle 为需要等待信号的类型 的 抽象基类，在后续随笔中会做详细介绍，在此不再多言。

            // 其中 WaitOrTimerCallback 为 回调函数委托
            // public delegate void WaitOrTimerCallback(object state, bool timedOut);

            // state 参数为 回调函数的传入参数

            // millisecondsTimeOutInterval 参数为 计时器超时周期， -1 为永不超时、即一直等待。
            // 对于此参数、第一次接触到的人可能有疑问、怎么还有周期？
            // 因为 信号可以重复接到多次、所以当每次接到信号后、或者超时后计时器都会重新计时, 所以有了周期的含义。

            // executeOnlyOnce， True 表示只执行一次, False 会一直等到该信号对象被取消注册，否则 只要接到信号或者超时就会触发回调函数。

            base.SetTip(nameof(ThreadPool.RegisterWaitForSingleObject));

            ThreadPool.RegisterWaitForSingleObject(this.waitObject, (state, timeout) =>
            {
                this.SetTip("++++++等待对象收到信号++++++");

            }, null, -, false);

            ThreadPool.QueueUserWorkItem((state) =>
            {
                this.SetTip("等待一秒");
                Thread.Sleep();

                this.SetTip("等待对象发出信号");
                this.waitObject.Set();

                this.SetTip("等待5秒");
                Thread.Sleep();

                this.SetTip("等待对象发出信号");
                this.waitObject.Set();

            });

三、Delegate.BeginInvoke

Delegate.BeginInvoke 间接的调用了线程池、从线程池中获取一个可用线程、执行当前委托所指向的函数指针所代表的方法。

        [Tag("Delegate.BeginInvoke")]
        private void Demo3()
        {
            this.txtTip.SetTip("UI, Id:" + Thread.CurrentThread.ManagedThreadId);

            Action action = new Action(this.DelegateTest);
            action.BeginInvoke(null, null);
            action.BeginInvoke(null, null);            

        }

        private void DelegateTest()
        {
            int id = Thread.CurrentThread.ManagedThreadId;

            this.Dispatcher.Invoke(() =>
            {
                this.txtTip.SetTip("BeginInvoke, Id:" + id);
            });
        }

通过 Thread.CurrentThread.ManagedThreadId 、我们也可以间接的证明 BeginInvoke 确实时在不同的线程中执行的。

当然，与之对应的是一系列的 Begin...  End...  方法对， 它们都是 IAsyncResult系列的异步编程模型中的一份子。

在 IAsyncResult系列的异步编程模型中，传递参数 和 获取返回值的Demo 见下：

        [Tag("Delegate.BeginInvoke带有参数和返回值")]
        private void Demo4()
        {
            Func<string, string> func = new Func<string, string>(this.DelegateTest2);

            this.txtTip.SetTip(" 输入参数 123 ");

            func.BeginInvoke(" 123 ", new AsyncCallback((System.IAsyncResult result) =>
            {
                Func<string, string> tmp = result.AsyncState as Func<string, string>;
                if (tmp != null)
                {
                    string returnResult = tmp.EndInvoke(result);

                    this.Dispatcher.Invoke(() =>
                    {
                        this.txtTip.SetTip(" 函数回调 结果 : " + returnResult);
                    });
                }
            }), func);

        }
        private string DelegateTest2(string args)
        {
            return args + " : Return args";
        }

四、Task

Task是在 .NET 4.0 中新增的，是基于任务的异步模型。它是对线程池的再次封装、使得可以更加方便的创建多种任务组合，如 顺序性的延续任务、父子任务。也可以方便的粗粒度地控制任务优先级。

1)Task.NET 4.0 中提倡的方式

Task 对外公开了构造函数、但是微软并不建议直接使用Task构造函数去实例化对象，而是 使用 Task.Factory.StartNew();

MSDN 中的备注如下：
For performance reasons, TaskFactory's StartNew method should be the preferred mechanism for creating and scheduling computational tasks,
but for scenarios where creation and scheduling must be separated, the constructors may be used,
and the task's Start method may then be used to schedule the task for execution at a later time.
Task 类还提供了初始化任务但不计划执行任务的构造函数。 出于性能方面的考虑，TaskFactory 的 StartNew 方法应该是创建和计划计算任务的首选机制，
但是对于创建和计划必须分开的情况，可以使用构造函数，然后可以使用任务的 Start 方法计划任务在稍后执行。

            Task.Factory.StartNew(() =>
            {
                base.SetTip("Task.Factory.StartNew(一个参数)");
            }).ContinueWith((t) =>
            {
                base.SetTip(t.Id.ToString());
                base.SetTip(t.CreationOptions.ToString());
            }).ContinueWith((t) =>
            {
                base.SetTip(t.Id.ToString());
                base.SetTip(t.CreationOptions.ToString());
            });

Task.Factory.StartNew 提供了高达16个的重载函数。
其中 Task.Factory.StartNew<TTask> 是创建带有返回值的异步任务。

以最复杂的重载为例、逐一介绍其参数
public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler);

function : 回调函数、我想没有必要做解释吧。
state : 回调函数的传入参数
CancellationToken: 用以取消Task （后续随笔会做详细介绍）
TaskCreationOptions: 指定可控制任务的创建和执行的可选行为的标志(后续随笔会做详细介绍)
TaskScheduler: 一个实例 TaskScheduler 类表示一个任务计划程序. 该值一般都是使用 TaskScheduler.Default

也就是说：
Task.Factory.StartNew(()=> { });
和
Task.Factory.StartNew(()=> { }, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
两种方式效果是一致的。

如果你想更精细化的控制任务、可以使用其他重载方法、传递不同参数以达到预想的目的。

2）Task初始化任务但并不计划执行

前文说过 Task 提供了构造函数、它提供了初始化任务，但并不去计划执行的方式。
让我们再看一下 Task 得构造函数吧，还是以最复杂的为例：
public Task(Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions);
其参数和 Task.Factory.StartNew 相比、 少了TaskScheduler。在性能方面MSDN提示后者会更好。

            base.SetTip("初始化任务");
            Task task = new Task(() =>
            {
                base.SetTip("被计划的任务开始执行");

                base.SetTip("任务休眠5秒");
                Thread.Sleep();

                base.SetTip("任务执行完毕");
            });

            // 为了保证能实时更新UI、看到代码执行效果、故而将代码异步执行
            Task.Factory.StartNew(() =>
            {
                base.SetTip("休眠两秒");
                Thread.Sleep();

                base.SetTip("将任务列入执行计划");
                task.Start();

                base.SetTip("等待Task执行完毕");
                task.Wait();// Wait方法 会等待Task执行完毕
                base.SetTip("Task执行完毕");
            });

另外再强调一点：Task.Start()， 只是将任务列入执行计划，至于任务什么时候去执行则取决于线程池中什么时候有可用线程。
Task.Factory.StartNew 也是一样的。

好了，Task类的介绍、到此为止，后续随笔再做详细介绍：这个强大的Task类，还有很多值得我们去探索的东西。

本随笔到此、暂告一段落。

附，Demo : http://files.cnblogs.com/files/08shiyan/ParallelDemo.zip

参见更多：随笔导读：同步与异步

(未完待续...)