Task是基于.net Framework3.0框架, Task使用的线程也是来自于ThreadPool
多线程的两个意义: 优化体验(常见于不卡界面), 提升运行速度(不同线程可以分担运算任务)
总结:
//Task6个方法:
WaitAll Task.WaitAny(taskList.ToArray());//会阻塞当前线程，等着某个任务完成后，才进入下一行 卡界面; 有好几个重载, 超时. . .
WaitAny //Task.WaitAny(taskList.ToArray());//会阻塞当前线程，等着[某个任务]完成后(只要有一个完成, 就会进入下一行代码)，才进入下一行 卡界面
应用场景
//一个业务查询操作有多个数据源 首页--多线程并发--拿到全部数据后才能返回 WaitAll
//一个商品搜素操作有多个数据源，商品搜索--多个数据源--多线程并发--只需要一个结果即可--
WhenAll 这个WhenAll啥也没有做, 就是表示当所有线程都把事情做完之后,然后再去做什么; 他必须要和ContinuWith一起使用, 否则便失去意义; Task.WhenAll(taskList).ContinueWith(()={"一起去吃饭"});翻译一下就是, 当tasklist中所有线程都完成工作了, 那么继续执行 一起去吃饭
WhenAny 这个和WhenAll一样. 但是指的是任意一个线程完成
ContinueWith ContinueWhenAll
taskFactory.ContinueWhenAll 在taskFactory中也有类似的WhenAll 和 WhenAny
//Task.Delay(1000);//延迟 不会卡
//Thread.Sleep(1000);//等待 卡
一. Task.Run→线程的启动是基于异步形式, 下面代码演示使用Task/new Task() / TaskFactory方式来启动线程:
Task.Run(() => this.DoSomethingLong("btnTask_Click1"));//Task的Run在.net 4.5 的时候才有
TaskFactory taskFactory = Task.Factory;//从.net 4.0开始才有
taskFactory.StartNew(() => this.DoSomethingLong("btnTask_Click3")); //利用TaskFactroy来启动一个新的线程
Task t = new Task(() => { Console.WriteLine("opasdfawerfwe"); });
t.Start();
二. 使用task实现等待当前线程完成, WaitAll和WaitAny, 然后继续后面的任务(卡界面):
////什么时候用多线程？ 任务能并发运行；提升速度；优化体验
List<Task> taskList = new List<Task>();
Console.WriteLine($"项目经理启动一个项目。。【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
taskList.Add(Task.Run(() => this.Coding("悟空", "Client")));//做客户端
taskList.Add(Task.Run(() => this.Coding("八戒", "Portal")));//做门户(后台)
taskList.Add(Task.Run(() => this.Coding("唐僧", "Service")));//做服务
taskList.Add(Task.Run(() => this.Coding("如来", "Jump"))); //做项目跳转
taskList.Add(Task.Run(() => this.Coding("沙僧", "Monitor")));//做监控系统
////阻塞：需要完成后再继续, 谁执行下面的Task, 就会阻塞谁
Task.WaitAll(taskList.ToArray());//会阻塞当前线程，等着 [全部任务] 完成后，才进入下一行 卡界面
Task.WaitAny(taskList.ToArray());//会阻塞当前线程，等着 [某个任务] 完成后(只要有一个完成, 就会进入下一行代码)，才进入下一行 卡界面,多线程加快速度，但是全部任务完成后，才能执行的操作
Task.WaitAny(taskList.ToArray(), 1000); //限时等待
Console.WriteLine($"告诉甲方验收，上线使用【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
小结:
waitAll→一个业务查询操作有多个数据源 首页--多线程并发--拿到全部数据后才能返回 WaitAll
WaitAny→一个商品搜素操作有多个数据源，商品搜索--多个数据源--多线程并发--只需要一个结果即可--WaitAny
三. 使用WaitAll或WaitAny即等待任务完成, 又不卡UI的方法, 包一层
Task.Run( //再包一层Task, 就是避开当前的UI线程来执行运算方法
() =>
{
//多线程加快速度，但是全部任务完成后，才能执行的操作
Task.WaitAll(taskList.ToArray());//会阻塞当前线程，等着全部任务完成后，才进入下一行 卡界面
Console.WriteLine($"告诉甲方验收，上线使用【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
四. 使用WhenAll 和 WhenAny, 来实现即不卡界面, 又可以控制执行顺序(等待所有任务完成, 才执行后续任务)
//当任何一个(WhenAny)线程完成任务, 就继续执行(ContinueWith)后面的动作
Task.WhenAny(taskList.ToArray()).ContinueWith(t =>
{
Console.WriteLine(taskList.ToArray().FirstOrDefault(s => s.Status == TaskStatus.RanToCompletion));
Console.WriteLine($"风骚的笑. . .【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
}) ;
//当所有(WhenAll)线程完成任务, 就继续执行(ContinueWith)后面的动作
Task.WhenAll(taskList.ToArray()).ContinueWith(t =>
{
Console.WriteLine($"部署环境，联调测试。。。【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
}) ;
五. 实战:
a) Task控制线程数量控制, 完成1000个任务, 但是最多只能启动11个线程, 代码如下:
//Task控制线程数量
List<int> list = new List<int>();
for (int i = 0; i < 10000; i++)
{
list.Add(i);
}
//项目规定完成10000个任务 但是最多只能有11个线程
Action<int> action = i =>
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString("00"));
Console.WriteLine($"当前i的值是→{ i.ToString("00")}");
Thread.Sleep(new Random(i).Next(100, 300));
};
List<Task> taskList = new List<Task>();
//将任务从list中取出来
foreach (var i in list)
{
int k = i;
taskList.Add(Task.Run(() => action.Invoke(k))); //每创建一个任务, 就将任务添加到itasklist中; 这里是异步执行的
if (taskList.Count > 10)//检查是否大于10, 就开始等待; 注意如果这样判断的话, 其实当前用了11个线程
{
//WaitAny 也是卡界面
Task.WaitAny(taskList.ToArray());//最起码要完成一个
//这一步检查线程的状态, 如果线程的状态不等于 已完成 的, 则继续保留在taskList中
taskList = taskList.Where(t => t.Status != TaskStatus.RanToCompletion).ToList();
//var v = taskList.Max(m => m.Id);
//Console.Write(v + "....................
.................");
}
}
//等待所有线程完成后, 开始后续的任务
Task.WhenAll(taskList.ToArray());
b) 使用TaskFactory的AsyncState来明确哪一个线程最先完成任务
//不能使用Task启动,使用TaskFactory是可以的, 可以使用t.AsyncState状态来标识
TaskFactory taskFactory1 = new TaskFactory();
List<Task> taskList = new List<Task>();
taskList.Add(taskFactory1.StartNew(o => this.Coding("悟空", "Client"), "悟空"));
taskList.Add(taskFactory1.StartNew(o => this.Coding("八戒", "Portal"), "八戒"));
taskList.Add(taskFactory1.StartNew(o => this.Coding("沙僧", "Service"), "沙僧"));
//只要有任何一个人完成任务之后, 就获取整个人的编号
taskFactory1.ContinueWhenAny(taskList.ToArray(), t =>
{
Console.WriteLine(t.AsyncState);
Console.WriteLine($"部署环境，联调测试。。。【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
});
//当所有的人都完成任务之后, 获取第一个完成任务的人
taskFactory1.ContinueWhenAll(taskList.ToArray(), tList =>
{
Console.WriteLine(tList[0].AsyncState);
Console.WriteLine($"部署环境，联调测试。。。【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");
});
c) Delay和Sleep
{
//Task.Delay(1000);//延迟 不会卡 ; 延迟1秒钟后, 执行后续动作
//Thread.Sleep(1000);//等待 卡
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Thread.Sleep(2000);
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds);
}
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
//不卡界面; 然后会等待2000毫秒后去执行continueWith中的函数;
Task.Delay(2000).ContinueWith(t =>
{
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds);
});
}
{
//使用Task.Run将Thread.Sleep包一层 同样可以实现不卡界面, 延迟执行
//Stopwatch stopwatch = new Stopwatch();
//stopwatch.Start();
//Task.Run(() =>
//{
// Thread.Sleep(2000);
// stopwatch.Stop();
// Console.WriteLine(stopwatch.ElapsedMilliseconds);
//});
}
d) Task指定回调 ; ContinueWith
Task.Run(() => this.Coding("悟空", "Client")).ContinueWith(t => { });
六. 使用Parallel并行编程, 在Task的基础上做了封装, 从.net Framework4.0开始
a) 使用Parallel并行编程完成一个多线程启动; 注意这个会卡界面; 因为主线程参与了计算
//当然这个也可以使用Task来完成
Parallel.Invoke(() => this.Coding("悟空", "Client")
, () => this.Coding("八戒", "Portal")
, () => this.Coding("沙僧", "Service"));
b) 一些简单API; 使用for和foreach
//for循环的操作; 启动5个线程; 0表示for的开始, 5表示结束; 简化的for
Parallel.For(0, 5, i => this.Coding("悟空", "Client" + i));
//使用foreach; 对集合中的每一个元素都执行后面的Action
Parallel.ForEach(new string[] { "0", "1", "2", "3", "4" }, i => this.Coding("悟空", "Client" + i));
c) 使用 parallel来控制当前最大的线程数量; 卡界面
//parallelOptions 可以控制并发数量;控制线程数量;
ParallelOptions parallelOptions = new ParallelOptions();
parallelOptions.MaxDegreeOfParallelism = 3; //任意时刻只有三个线程在执行
Parallel.For(0, 10, parallelOptions, i => this.Coding("悟空", "Client" + i));
d) 使用 parallel来控制当前最大的线程数量; 不卡界面
Task.Run(() =>
{
ParallelOptions parallelOptions = new ParallelOptions();
parallelOptions.MaxDegreeOfParallelism = 3;
Parallel.For(0, 10, parallelOptions, i => this.Coding("悟空", "Client" + i));
});
e) Parallel的break和stop, 不推荐使用
//Break Stop 都不推荐用
ParallelOptions parallelOptions = new ParallelOptions();
parallelOptions.MaxDegreeOfParallelism = 3;
Parallel.For(0, 40, parallelOptions, (i, state) =>
{
if (i == 2)
{
Console.WriteLine($"线程Break，当前任务结束 i={i} {Thread.CurrentThread.ManagedThreadId.ToString("00")}");
state.Break();//结束Parallel当次的这一次操作 结束了当前的线程的操作, 如果当前线程操作了很多i , 那么这个线程所操作的i就不会输出了; 但是如果当前线程如果是主线程的话, 那么它会直接结束Parallel的, 这要看运气了. . .
return;//必须带上
}
//if (i == 20)
//{
// Console.WriteLine($"线程Stop，Parallel结束 i={i} {Thread.CurrentThread.ManagedThreadId.ToString("00")}");
// state.Stop();//结束Parallel全部操作 等于break
// return;//必须带上
//}
this.Coding("悟空", "Client" + i);
});
//Break 实际上结束了当前这个线程；如果是主线程，等于Parallel都结束了
//多线程的终止本身就不靠谱
Task.Run( //再包一层Task, 就是避开当前的UI线程来执行运算方法
() =>
{
//多线程加快速度，但是全部任务完成后，才能执行的操作
Task.WaitAll(taskList.ToArray());//会阻塞当前线程，等着全部任务完成后，才进入下一行 卡界面
Console.WriteLine($"告诉甲方验收，上线使用【{Thread.CurrentThread.ManagedThreadId.ToString("00")}】");