多线程-Task、await/async

Task创建无返回值

Task是.netframwork4.0重新分装的多线程类。原因以前的多线程（thread threadpool）不好用。（.net framwork也是的发展的，现在的EF，刚开始是一个edmx文件，现在的code first，ef轻量级。但是其他有的技术也是死掉了）

Task具有线程执行的可控性，返回值，代码书写简单，性能好等特点。

Task创建主要有三种方式

1、Task参数

Task t = new Task(() =>
{
    for (int i = ; i < ; i++)
    {
        Console.WriteLine(i);
    }
});
t.Start();

Action，Action<object>，object state，CancellationToken，TaskCreationOptions

Action<object>：task创建有参数的任务，参数只能是object

object：带有参数委托的参数。

CancellationToken：线程取消通知

TaskCreationOptions：控制Task的执行方式

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

2、Task.Factory.StartNew

Action，Action<object>，object state，CancellationToken，TaskCreationOptions，TaskScheduler

TaskScheduler：定义：用于计划所创建的 System.Threading.Tasks.Task 的 System.Threading.Tasks.TaskScheduler。（并看不出来是什么意思，英文意思 任务调度器）

返回值是一个Task

Task.Factory.StartNew(() =>
{
    for (int i = ; i < ; i++)
    {
        Console.WriteLine(i);
    }
});

3、TaskFactory

Task.Factory是TaskFactory的一个实例。

TaskFactory tf = new TaskFactory();
tf.StartNew(() =>
{
    for (int i = ; i < ; i++)
    {
        Console.WriteLine(i);
    }
});

上面的都是不带返回参数的任务

Task创建有返回值

一般项目中的返回类型都会特定的封装一个通用的类型。所有都会有返回值。

Task<string> t = new Task<string>(GetName);
t.Start();
Console.WriteLine(t.Result);
Console.WriteLine("结束");

public static string GetName()
{
    for (int i = ; i < ; i++)
    {
        Console.WriteLine(i);
    }
    return "臧峰";
}

注意在获取返回值的时候，t.Result会卡着线程，一只等待线程返回结果。

Task等待

1、为什么要等待呢，因为线程大部分都要计算已给结果，所以我们要等待这个结果。

2、public void Wait(。。。。);

位于Task类中（实例方法。另外还有几个静态方法）。

定义：等待 System.Threading.Tasks.Task 完成执行过程（卡着其他线程）。

参数可以设置等待时间，CancellationToken（任务取消）  等待期间可以取消任务。

3、public static void WaitAll(params Task[] tasks....);

定义：等待提供的所有 System.Threading.Tasks.Task 对象完成执行过程。（就是当前线程要等这个参数列表中线程全部执行完后  才执行。注意：waitall前面其他的子线程还是在继续执行）

参数：等待任务列表，事件，CancellationToken

4、public static int WaitAny(params Task[] tasks);

定义：等待提供的任一 System.Threading.Tasks.Task 对象完成执行过程。

参数：等待任务列表，事件，CancellationToken

5、Task的属性方法

AsyncState	就是当任务核心方法带参数的时候，参数值
Status	任务执行进度的状态
CreationOptions	任务创建和执行的行为
Id	任务线程ID
IsCanceled	任务是否被取消
IsCompleted	任务是否完成
IsFaulted	任务是否失败
Result	任务返回值，该值只适用于有返回参数的任务

ContinueWith()	线程执行完之后执行另外一个任务
GetAwaiter()	获取等待这个线程的等待着
Start()	发起一个任务
Wait()	当前调用wait的任务线程等待

这些是常用的

Task回调

//------------------------Task回调-------------------------
Task<int> t = new Task<int>(() =>
{
    var temp = ;
    for (int i = ; i < ; i++)
    {
        temp += i;
    }
    return temp;
});

t.ContinueWith<string>((f) =>
{
    Console.WriteLine(f.Result.ToString());
    return f.Result.ToString();
});
t.Start();

//------------------TaskFactory回调----------------------------
TaskFactory<int> tf = new TaskFactory<int>();
var tft = tf.StartNew(() =>
 {
     var temp = ;
     for (int i = ; i < ; i++)
     {
         temp += i;
     }
     return temp;
 });
tft.ContinueWith<string>((f) =>
{
    Console.WriteLine(f.Result.ToString());
    return f.Result.ToString();
});

//-----------------------ContinueWhenAll--------------------------
var cts = new CancellationTokenSource();
TaskFactory<int> tf1 = new TaskFactory<int>(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

Task<int> t1 = tf1.StartNew(() => { Console.WriteLine(); return ; });
Task<int> t2 = tf1.StartNew(() => { Console.WriteLine(); return ; });
Task<int> t3 = tf1.StartNew(() => { Console.WriteLine(); return ; });
Task<int> t4 = tf1.StartNew(() => { Console.WriteLine(); return ; });
Task<int> t5 = tf1.StartNew(() => { Console.WriteLine(); return ; });

//意思就是说当这些所有的线程都执行完了，在执行后面的线程
//第一个参数就是要执行的线程数组
//第二个参数就是   继续执行的线程
var tcwa = tf1.ContinueWhenAll(new[] { t1, t2, t3, t4, t5 }, tlReturn =>
 {
     int temp = ;
     for (int i = ; i < tlReturn.Length; i++)
     {
         temp += tlReturn[i].Result;
     }
     Console.WriteLine(temp);
     return temp;
 });

var tft1 = tf1.StartNew(() =>
{
    var temp = ;
    for (int i = ; i < ; i++)
    {
        temp += i;
    }
    Console.WriteLine(temp);
    return temp;
});

//-------------------------FromAsync-----------------------------------
TaskFactory<long> tfFA = new TaskFactory<long>();
Func<long> faDel = (() =>
{
    Console.WriteLine("臧锋");
    return ;
});
tfFA.FromAsync(faDel.BeginInvoke(null, null), (tr) =>
{
    Console.WriteLine(tr.IsCompleted);
    return ;
});

还是先了解一下TaskFactory

ContinueWhen不会卡当前线程。wait会卡当前线程。

CancellationToken	任务取消标记
ContinuationOptions	字面意思 任务延续选择。官方注释不敢恭维。和ContinueWhenAll、ContinueWhenAny有关
CreationOptions	指定此任务工厂的默认创建选项。（任务执行顺序，是否长时间执行...）
Scheduler	任务工厂的任务计划程序。表示一个处理将任务排队到线程中的低级工作的对象。

ContinueWhenAll	创建一个延续任务，它将在提供的组中的所有任务完成后马上开始。第一个参数P1：线程列表，就是要执行的线程 （必须有调用ContinueWhenAll的TaskFactory创建）    第二个参数P2：回调函数 (回调函数的第一个参数为第一个参数P1，回调函数第二个参数为返回值，由TaskFactory<>定义的)。 执行顺序  P1先执行，然后P2执行。   TaskFactory的任务为随机执行
ContinueWhenAny	创建一个延续任务，它将在提供的组中的任何任务完成后马上开始。
FromAsync	创建一个任务，它在指定的 System.IAsyncResult 完成时执行一个结束方法函数。（官方解释有点绕  其实就是 通过它可以把一个异步的任务转换为一个Task，返回值是一个Task，最后在执行一个回调函数） 吐槽一下，官方的翻译是不是都是电脑翻译的。
StartNew	创建开启任务

Task取消

主要是类CancellationTokenSource

定义：通知 System.Threading.CancellationToken，告知其应被取消。

可以马上取消，还可以设置时间取消。

CancellationTokenSource clt = new CancellationTokenSource();
TaskFactory tf = new TaskFactory(clt.Token);
tf.StartNew(() =>
{
    int temp = ;
    for (int i = ; i < ; i++)
    {
        Thread.Sleep();
        if (!clt.IsCancellationRequested)
        {
            temp += i;
        }
        else
        {
            break;
        }
    }
    Console.WriteLine(temp);
});
Thread.Sleep();
clt.Cancel();

Task返回值

具有返回值的是要用泛型  指定返回值类型。

Task<int> t = new Task<int>(() => );
t.Start();
Console.WriteLine(t.Result);

TaskFactory<int> tf = new TaskFactory<int>();
var  tft= tf.StartNew(() => { return ; });
Console.WriteLine(tft.Result);

最后通过Task.Result得到结果。这个操作会卡着线程，一直等待回去结果。

 Parallel并行任务

1、Parallel  定义：提供对并行循环和区域的支持。静态类，静态方法。他是基于Task，线程池。

其实是操作循环任务，但是循环的任务都是在平行执行的，没人先后顺序，但是，循环结会等待他们都结束的。

Parallel.For

Parallel.ForEach

Parallel.Invok

优点：主线程也会参与计算，缺点：就是会waitall   会卡住当前线程。

2、ParallelLoopResult 定义：提供执行 System.Threading.Tasks.Parallel 循环的完成状态。其实就是For和ForEach的返回值

3、ParallelLoopState 定义：可用来使 System.Threading.Tasks.Parallel 循环的迭代与其他迭代交互。此类的实例由 Parallel 类提供给每个循环；不能在您的用户代码中创建实例。

他可以让循环退出 ，通知。  （就像for循环中的bread）

4、ParallelOptions 定义：存储用于配置 System.Threading.Tasks.Parallel 类的方法的操作的选项。

//
// 摘要:
//     获取或设置与此 System.Threading.Tasks.ParallelOptions 实例关联的 System.Threading.CancellationToken。
//
// 返回结果:
//     与此实例关联的标记。
public CancellationToken CancellationToken { get; set; }
//
// 摘要:
//     获取或设置此 System.Threading.Tasks.ParallelOptions 实例所允许的最大并行度。
//
// 返回结果:
//     一个表示最大并行度的整数。
//
// 异常:
//   T:System.ArgumentOutOfRangeException:
//     该属性被设置为 0 或小于 -1 的值。
public int MaxDegreeOfParallelism { get; set; }
//
// 摘要:
//     获取或设置与此 System.Threading.Tasks.ParallelOptions 实例关联的 System.Threading.Tasks.TaskScheduler。将此属性设置为
//     null，以指示应使用当前计划程序。
//
// 返回结果:
//     与此实例关联的任务计划程序。
public TaskScheduler TaskScheduler { get; set; }

可以取消任务，并行的数量（循环中一次并行执行任务的个数，当任务量比较大的时候，一定要指定这个值，不然电脑可能撑不住。但是他是基于线程池的，线程池会帮我们控制一下，但是还是会卡电脑。并行数量控制，导致起的线程是一轮一轮的，每一轮第一个线程ID都一样，用的主线程ID）

5、总结

Parallel.For()和Paraller.ForEach()方法在每次迭代中调用相同的代码，而Parallel.Invoke()方法允许同时调用不同的方法。Parallel.ForEach()用于数据并行性，Parallel.Invoke()用于任务并行性；

主线程可以参与计算，但是要waitall。等待。

Await Async

1、出现介绍

C#5.0                  C#语言版本

.net fromwork 4.5                框架类库版本FCL

clr4.0                  CLR版本

await async他是一个语法糖。什么是语法糖呢，就是c#或者.net fromwork改变但是clr没有改变。

泛型就不是语法糖，他出现的时候clr重写了，就是使用泛型的地方，  对应的生成相应的类型方法。

没有task就没有await async

2、原理

是一个语法糖，利用一个状态机的概念，通过编译器编译把await后面的代码封装为一个委托进行回调执行，并且await会等待执行完成，状态机就是这一个执行完之后，就movenest执行下一个回调。就是await一层层的嵌套就可以了。

3、使用

await只能出现在task前面，await后面的代码变成task的回调。快速的写出了异步回调

返回值只能是void task  task<>，推荐使用task<>返回值，并封装通用T类型。

本文代码下载

补充例子