(精华)2020年8月12日 C#基础知识点 异步专题(发展史，多线程，多进程，协程，单线程非阻塞)
一：引言
/// .NetFramework1.0就有多线程！
/// 进程：计算机概念，程序运行在服务器占据的全部计算机的资源
/// 线程：计算机概念，是进程在相应操作时候的一个最小单元，也包括cpu/硬盘/内存 虚拟概念
/// 进程和线程：包含关系，线程是属于某一个进程的，如果一个进程销毁，线程也就不会存在。
/// 句柄：描述程序中的某一个最小单元，是一个long数字，操作系统通过这个数字识别应用程序。
/// 多线程：计算概念，就是某一个进程中，多个线程同时运行；
///
/// C#中的多线程：
/// Thread类是C#语言对线程对象一个封装；
///
/// 为什么可以多线程呢？
///
/// 1、Cpu有多个核；可以并行计算；
/// 双核四线：这里的线程是模拟核；
///
/// 2、cpu分片：某1s的处理能切分成1000份，操作系统调度去相应不同的任务；
/// 从宏观角度来说：感觉就有多个任务在并发执行；
/// 从微观角度来说：一个物理cpu不能在某一刻为某一个任务服务
///
/// 同步异步：
/// 同步方法：发起调用，只有在调用的方法完成以后，才能继续执行一下一行代码，按照顺序执行；
/// 诚心请吃饭，我请你吃饭，你说你现在需要忙一会儿，我等你，等你忙完了以后，咱们一起去吃饭。
///
/// 异步方法：发起调用，不等待完成，直接进入下一行代码的执行，启动一个新的线程来完成计算
///
/// 客气一下请人吃饭：我请你吃饭，你说你现在需要忙一会儿，我就不等你了，我自己先去吃饭了，你忙完以后，自己去吃饭。
二：同步和异步的比较
#region Sync
/// <summary>
/// 同步方法
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnSync_Click(object sender, EventArgs e)
{<!-- -->
Console.WriteLine($"****************btnSync_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
int l = 3;
int m = 4;
int n = l + m;
for (int i = 0; i < 5; i++)
{<!-- -->
string name = string.Format($"btnSync_Click_{i}");
this.DoSomethingLong(name);
}
Console.WriteLine($"****************btnSync_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
}
#endregion
#region Async
/// <summary>
/// 异步方法：
/// 1、同步方法卡界面：主线线程（UI线程）忙于计算，无暇他顾
/// 异步方法不卡界面：因为异步方法是新启动一个线程去完后计算，主线程闲置
/// 改善用户体验，winform程序点击某一个按钮，不会卡死界面；
/// 发短信，发邮件可以交给一个子线程去完成
///
/// 2、同步方法执行慢:只有一个线程完成计算
/// 异步方法执行快：多个线程去完成计算
/// 10000ms 3000ms 快了三倍多
/// 20000ms 15000ms cpu密集型计算
/// 资源换性能
///
/// 3、同步方法有序执行，异步多线程无顺序
/// 启动无序，线程资源是向操作系统申请的，操作系统有自己的调度策略，所以启动是随机的；
/// 以上两点得出： 结束也是没有顺序
///
/// 如果需要控制顺序呢？怎么实现?
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnAsync_Click(object sender, EventArgs e)
{<!-- -->
Console.WriteLine($"****************btnAsync_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
Action<string> action = this.DoSomethingLong;
for (int i = 0; i < 5; i++)
{<!-- -->
action.BeginInvoke("btnAsync_Click", null, null);
}
Console.WriteLine($"****************btnAsync_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
}
#endregion
#region Private Method
/// <summary>
/// 一个比较耗时耗资源的私有方法
/// </summary>
/// <param name="name"></param>
private void DoSomethingLong(string name)
{<!-- -->
Console.WriteLine($"****************DoSomethingLong Start {name} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
long lResult = 0;
Thread.Sleep(2000);//线程等待
Console.WriteLine($"****************DoSomethingLong End {name} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}***************");
}
#endregion
private void btnAsyncAdvanced_Click(object sender, EventArgs e)
{<!-- -->
Console.WriteLine($"****************btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
IAsyncResult asyncResult = null;
AsyncCallback callback = ar =>
{<!-- -->
Thread.Sleep(5000);
Console.WriteLine($"这里是beginInvoke的第三个参数{ar.AsyncState}");
Console.WriteLine(object.ReferenceEquals(ar, asyncResult));
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy - MM - dd HH: mm:ss.fff")}");
Console.WriteLine("计算结束");
};
{<!-- -->
//1、回调
Action<string> action = this.DoSomethingLong;
//把自定义的参数传入到回调函数中去
asyncResult = action.BeginInvoke("btnAsyncAdvanced_Click", callback, "八万公里");
//2、IsCompleted 完成等待
{<!-- -->
int i = 0;
while (!asyncResult.IsCompleted)
{<!-- -->
if (i < 9)
{<!-- -->
Console.WriteLine($"正在玩命为你加载中。。。已经完成{++i * 10}%");
}
else
{<!-- -->
Console.WriteLine($"正在玩命为你加载中。。。已经完成99.9999%");
}
Thread.Sleep(200);
}
Console.WriteLine("加载完成。。。");
}
//以上两种都是为了等待任务的完成；
//3、WaitOne等待
asyncResult.AsyncWaitHandle.WaitOne();//一直等待任务完成
asyncResult.AsyncWaitHandle.WaitOne(-1);//一直等待任务完成
asyncResult.AsyncWaitHandle.WaitOne(3000);//最多等待3000ms,如果超时了，就不等待了
{<!-- -->
//4、EndInvoke也可以等待，可以获取委托返回值
Func<int> func = () =>
{<!-- -->
//Thread.Sleep(5000);
return DateTime.Now.Year;
};
func.Invoke();
IAsyncResult asyncResult1 = func.BeginInvoke(ar =>
{<!-- -->
func.EndInvoke(ar);
}, null);
int iResult = func.EndInvoke(asyncResult1);
Console.WriteLine(iResult);
}
Console.WriteLine($"****************btnAsyncAdvanced_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
}
三：.NetFramework1.0（Thread）
{<!-- -->
ParameterizedThreadStart threadStart = ar =>
{<!-- -->
this.DoSomethingLong("btnThread_Click");
Console.WriteLine($"****************btnThread_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
};
Thread thread = new Thread(threadStart);
thread.Start(); //开启一个新线程
}
{<!-- -->
ThreadStart threadStart = () =>
{<!-- -->
Thread.Sleep(5000);
this.DoSomethingLong("btnThread_Click");
Console.WriteLine($"****************btnThread_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
};
Thread thread = new Thread(threadStart);
thread.Start(); //开启一个新线程
thread.Suspend();// 暂停线程
thread.Resume();//恢复 无法实时的去暂停或者恢复线程
thread.Abort();//终结线程
Thread.ResetAbort();//都会有延时
//如果我们需要等待；
//1、等待
while (thread.ThreadState != ThreadState.Stopped)
{<!-- -->
Thread.Sleep(200);
}
//2、Join等待
thread.Join();//可以限时等待
thread.Join(2000); //可以限时等待
thread.Priority = ThreadPriority.Highest;//设置线程优先级，只是增加他的优先概率；并不能一定的
thread.IsBackground = true;//为后台线程 进程结束，线程结束了
thread.IsBackground = false; //前台线程 进程结束后，任务执行完毕以后，线程才结束
{<!-- -->
ThreadStart threadStart1 = () =>
{<!-- -->
Console.WriteLine($"****************btnThread_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
Thread.Sleep(3000);
};
Action action = () =>
{<!-- -->
Console.WriteLine($"****************btnThread_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
Thread.Sleep(3000);
};
this.ThreadWithCallBack(threadStart1, action);
}
{<!-- -->
//Thread开启一个新的线程执行任务，如何获取返回结果：
Func<int> func = () =>
{<!-- -->
Thread.Sleep(5000);
return DateTime.Now.Year;
};
Func<int> FuncResult = this.ThreadWithReturn(func);
int iResult = FuncResult.Invoke();//如果需要得到执行结果，是必须要等待的
}
}
/// <summary>
/// 开启线程执行委托函数
/// </summary>
/// <param name="threadStart"></param>
/// <param name="actionCallback"></param>
private void ThreadWithCallBack(ThreadStart threadStart, Action actionCallback)
{<!-- -->
ThreadStart threadStart1 = new ThreadStart(() =>
{<!-- -->
threadStart.Invoke();
actionCallback.Invoke();
});
Thread thread = new Thread(threadStart1);
thread.Start();
}
/// <summary>
/// 既要不卡界面，又需要返回结果
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="func"></param>
/// <returns></returns>
private Func<T> ThreadWithReturn<T>(Func<T> func)
{<!-- -->
T t = default(T);
ThreadStart threadStart = new ThreadStart(() =>
{<!-- -->
t = func.Invoke();
});
Thread thread = new Thread(threadStart);
thread.Start();
return new Func<T>(() =>
{<!-- -->
thread.Join();
return t;
});
}
四：.NetFramework2.0（ThreadPool）
/// <summary>
/// 线程池
/// .NetFramework2.0
/// 在Thread中对线程的管理需要我们自己去从操作，在不断的开启线程和销毁中，存在很大的开销，为了让线程可以反复的使用，出现了池化思想！
/// 可以节省资源，线程池还可以控制线程总数量，防止滥用！
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnThreadPool_Click(object sender, EventArgs e)
{<!-- -->
Console.WriteLine($"****************btnThreadPool_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
{<!-- -->
ThreadPool.QueueUserWorkItem(o =>
{<!-- -->
Console.WriteLine($"**************** {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
this.DoSomethingLong("ThreadPool.QueueUserWorkItem1");//开启了一个线程
});
}
{<!-- -->
ThreadPool.QueueUserWorkItem(o =>
{<!-- -->
Console.WriteLine($"第二个参数：{o}");
this.DoSomethingLong("ThreadPool.QueueUserWorkItem1");//开启了一个线程
}, "Hyl");
}
{<!-- -->
ThreadPool.GetMaxThreads(out int maxWorkerThreads, out int maxCompletionPortThreads);
ThreadPool.GetMinThreads(out int minWorkerThreads, out int minCompletionPortThreads);
Console.WriteLine($"当前电脑最大workerThreads={maxWorkerThreads},最大的completionPortThreads={maxCompletionPortThreads}");
Console.WriteLine($"当前电脑最小workerThreads={minWorkerThreads},最小的completionPortThreads={minCompletionPortThreads}");
Console.WriteLine("设置线程数量之后：");
//设置线程数量是全局，线程池是全局，Task,async/awit 都是来自于线程，老师不建议大家随便设置！
ThreadPool.SetMaxThreads(2, 2); //这里在设置的时候，数量不能低于本计算机的 核数
ThreadPool.SetMinThreads(2, 2);
ThreadPool.GetMaxThreads(out int maxWorkerThreads1, out int maxCompletionPortThreads1);
ThreadPool.GetMinThreads(out int minWorkerThreads1, out int minCompletionPortThreads1);
Console.WriteLine($"当前电脑最大workerThreads={maxWorkerThreads1},最大的completionPortThreads={maxCompletionPortThreads1}");
Console.WriteLine($"当前电脑最小workerThreads={minWorkerThreads1},最小的completionPortThreads={minCompletionPortThreads1}");
}
{<!-- -->
//线程等待：
//在线程池中，有一个开关式
ManualResetEvent manualResetEvent = new ManualResetEvent(false); //开关关闭
ThreadPool.QueueUserWorkItem(o =>
{<!-- -->
this.DoSomethingLong("btnThreadPool_Click1");
Thread.Sleep(3000);
manualResetEvent.Set();// 开关打开
});
manualResetEvent.WaitOne();//执行到这儿来的时候，我就等你给我发信号
Console.WriteLine("计算完成");
}
{<!-- -->
ThreadPool.SetMaxThreads(8, 8);//设置了最大的线程数量
ManualResetEvent manualResetEvent = new ManualResetEvent(false); //开关关闭
for (int i = 0; i < 10; i++)
{<!-- -->
int k = i;
ThreadPool.QueueUserWorkItem(t =>
{<!-- -->
Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
if (k == 9)
{<!-- -->
manualResetEvent.Set();
}
else
{<!-- -->
manualResetEvent.WaitOne();
}
});
}
if (manualResetEvent.WaitOne())
{<!-- -->
Console.WriteLine("执行成功！");
}
}
Console.WriteLine($"****************btnThreadPool_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
}
五：.NetFramework3.0（Task）
/// <summary>
/// Task 是.NetFramework3.0出现的。提供了非常多的Api
/// Task里面的线程是来自于线程池！
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btntask_Click(object sender, EventArgs e)
{<!-- -->
Console.WriteLine($"****************btnThreadPool_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
{<!-- -->
Task task = new Task(() =>
{<!-- -->
this.DoSomethingLong("btntask_Click1");
});
task.Start();//开启了一个新的线程
}
{<!-- -->
Task.Run(() =>
{<!-- -->
this.DoSomethingLong("btntask_Click2");
});
}
{<!-- -->
//TaskFactory taskFactory = new TaskFactory();
TaskFactory taskFactory = Task.Factory;
taskFactory.StartNew(() =>
{<!-- -->
this.DoSomethingLong("btntask_Click3");
});
}
{<!-- -->
Thread thread = new Thread(() => {<!-- --> Console.WriteLine("开启了一个新线程"); });
thread.Start();
ThreadPool.QueueUserWorkItem(o => {<!-- --> Console.WriteLine("开启了一个新线程"); });
}
{<!-- -->
{<!-- -->
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Thread.Sleep(2000);
stopwatch.Stop();
Console.WriteLine($"{stopwatch.ElapsedMilliseconds}");
}
{<!-- -->
// Task.Delay 出现于4.5版本
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Task task = Task.Delay(2000).ContinueWith(t => //任务在2000ms 以后执行
{<!-- -->
stopwatch.Stop();
Console.WriteLine($"{stopwatch.ElapsedMilliseconds}");
Console.WriteLine("回调已完成");
});
}
}
{<!-- -->
//可以并发执行的时候就可以使用多线程
List<Task> tasksList = new List<Task>();
TaskFactory taskFactory = new TaskFactory();
tasksList.Add(taskFactory.StartNew(() => {<!-- --> this.Coding("001", "系统管理"); }));
tasksList.Add(taskFactory.StartNew(() => {<!-- --> this.Coding("002", "部门管理"); }));
tasksList.Add(taskFactory.StartNew(() => {<!-- --> this.Coding("003", "客户管理"); }));
tasksList.Add(taskFactory.StartNew(() => {<!-- --> this.Coding("004", "接口管理"); }));
tasksList.Add(taskFactory.StartNew(() => {<!-- --> this.Coding("005", "写Api"); }));
//如果有一个同学完成了某一个模块，老师就需要准备环境！
// 等待某一个线程执行完毕以后 继续往后执行
Task.WaitAny(tasksList.ToArray());
Task.WaitAll(tasksList.ToArray()); //阻塞主线程
}
Console.WriteLine($"****************btnThreadPool_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
}
六：.NetFramework4.5（Parallel ）
/// <summary>
/// Parallel 对Task进一步进行了封装 .Netframework 4.5版本出来
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnParallel_Click(object sender, EventArgs e)
{<!-- -->
Console.WriteLine($"**************** btnParallel_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
{<!-- -->
//多线程中控制执行顺序，一直是一个难题，使用Parallel可以控制线程的执行顺序。
//Parallel并发执行了五个委托，开启了新线程，主线程参与计算，界面会阻塞
// Task WaitAll + 主线程
Parallel.Invoke(() => {<!-- --> this.DoSomethingLong("btnParallel_Click_1"); },
() => {<!-- --> this.DoSomethingLong("btnParallel_Click_2"); },
() => {<!-- --> this.DoSomethingLong("btnParallel_Click_3"); },
() => {<!-- --> this.DoSomethingLong("btnParallel_Click_4"); },
() => {<!-- --> this.DoSomethingLong("btnParallel_Click_5"); });
}
{<!-- -->
ParallelOptions parallelOptions = new ParallelOptions();
parallelOptions.MaxDegreeOfParallelism = 2;//最大并行数
Parallel.For(0, 10, parallelOptions, t => this.DoSomethingLong($"btnParallel_Click_{t}"));
}
{<!-- -->
控制线程数量
ParallelOptions parallelOptions = new ParallelOptions();
parallelOptions.MaxDegreeOfParallelism = 2; //控制线程的最大数量
//控制执行数量
Parallel.ForEach(new int[] {<!-- --> 12, 13, 14, 15, 16, 17 }, parallelOptions, t => this.DoSomethingLong($"btnParallel_Click_{t}"));
}
Console.WriteLine($"**************** btnParallel_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
}
七：多线程异常处理和异常取消
/// <summary>
/// 多线程异常处理
/// 线程取消
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnThreadCore_Click(object sender, EventArgs e)
{<!-- -->
Console.WriteLine($"**************** btnThreadCore_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
//多线程中如果某一个线程异常了，就会终结当前线程；对其他的线程是没有影响的；
//多线程中的异常去哪儿了？
//被吞掉了
#region 多线程异常处理
{<!-- -->
Thread thread = new Thread('执行方法');
thread.Abort();
try
{<!-- -->
List<Task> taskList = new List<Task>();
for (int i = 0; i < 100; i++)
{<!-- -->
string name = $"btnThreadCore_Click_{i}";
int k = i;
taskList.Add(Task.Run(() =>
{<!-- -->
if (k == 5)
{<!-- -->
throw new Exception($"{name} 异常了");
}
else if (k == 6)
{<!-- -->
throw new Exception($"{name} 异常了");
}
else if (k == 10)
{<!-- -->
throw new Exception($"{name} 异常了");
}
Console.WriteLine($"this is {name} Ok!");
}));
};
Task.WaitAll(taskList.ToArray());
}
catch (AggregateException aex) //可以有多个Catch 在匹配异常类型的时候，先具体，然后在寻找父类
{<!-- -->
foreach (var exception in aex.InnerExceptions)
{<!-- -->
Console.WriteLine(exception.Message);
}
}
catch (Exception ex)
{<!-- -->
Console.WriteLine(ex.Message);
throw;
}
//在实际的工作中，往往有很多场景是如果发生异常之后，其他的线程就需要取消，不再继续往下执行；问题就是如何取消线程；
}
#endregion
#region 线程取消
{<!-- -->
//全局变量
//bool IsOk = true;
CancellationTokenSource cts = new CancellationTokenSource();// 通知式的
try
{<!-- -->
List<Task> taskList = new List<Task>();
for (int i = 0; i < 100; i++)
{<!-- -->
string name = $"btnThreadCore_Click_{i}";
int k = i;
taskList.Add(Task.Run(() =>
{<!-- -->
if (k == 5)
{<!-- -->
throw new Exception($"{name} 异常了");
}
if (!cts.IsCancellationRequested)//是否取消
{<!-- -->
Console.WriteLine($"this is {name} Ok!");
}
else
{<!-- -->
Console.WriteLine($"this is {name} Stop!");
}
}));
};
Task.WaitAll(taskList.ToArray());
}
catch (AggregateException aex) //可以有多个Catch 在匹配异常类型的时候，先具体，然后在寻找父类
{<!-- -->
cts.Cancel(); //执行该方法以后，IsCancellationRequested会被指定为false
foreach (var exception in aex.InnerExceptions)
{<!-- -->
Console.WriteLine(exception.Message);
}
}
catch (Exception ex)
{<!-- -->
Console.WriteLine(ex.Message);
throw;
}
}
#endregion
Console.WriteLine($"**************** btnThreadCore_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} ***************");
}
八：多线程安全问题
private static readonly object Obj_Lock = new object();
//1 Lock；不能锁null,不建议大家锁String; 锁 this
//使用锁：private static readonly object Obj_Lock = new object()
//锁的作用：排他
//2 线程安全集合
// System.Collections.Concurrent.ConcurrentStack 基于线程安全
//3 数据分拆，避免多个线程操作同一堆数据，安全又高效率
//保证线程安全不会使用同一个变量
for (int i = 0; i < 100000; i++)
{<!-- -->
this.NumOne += 1;
}
for (int i = 0; i < 100000; i++)
{<!-- -->
Task.Run(() =>
{<!-- -->
try
{<!-- -->
lock (Obj_Lock )//可以 避免多线程并发，如果锁住以后，其实这里跟单线程 基本上没啥区别；
{<!-- -->
this.NumTow += 1;
}
}
catch (Exception)
{<!-- -->
throw;
}
});
}
/// <summary>
/// new Random().Next(1, 100); 多线程同时执行结果很高概率相同，
/// 是用的当前时间为seed，时间相同结果相同
///
/// 解决随机数重复问题
/// 同时模拟远程请求的随机延时
/// </summary>
public class RandomHelper
{<!-- -->
/// <summary>
/// 随机获取数字并等待1~2s
/// </summary>
/// <returns></returns>
public int GetRandomNumberDelay(int min, int max)
{<!-- -->
Thread.Sleep(this.GetRandomNumber(500, 1000));//随机休息一下
return this.GetRandomNumber(min, max);
}
/// <summary>
/// 获取随机数，解决重复问题
/// </summary>
/// <param name="min"></param>
/// <param name="max"></param>
/// <returns></returns>
public int GetRandomNumber(int min, int max)
{<!-- -->
Guid guid = Guid.NewGuid();//每次都是全新的ID
string sGuid = guid.ToString();
int seed = DateTime.Now.Millisecond;
for (int i = 0; i < sGuid.Length; i++)
{<!-- -->
switch (sGuid[i])
{<!-- -->
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
seed = seed + 1;
break;
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
seed = seed + 2;
break;
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
seed = seed + 3;
break;
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z':
seed = seed + 3;
break;
default:
seed = seed + 4;
break;
}
}
Random random = new Random(seed);
return random.Next(min, max);
}
}
九：最终版(async/await)
public class AwaitAsyncClass
{<!-- -->
public async static void TestShow()
{<!-- -->
Test();
}
private async static Task Test()
{<!-- -->
Console.WriteLine($"当前主线程id={Thread.CurrentThread.ManagedThreadId.ToString("00")}");
{<!-- -->
Task t = NoReturnTask();
Console.WriteLine($"Main Thread Task ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
t.Wait();//主线程等待Task的完成 阻塞的
await t;//await后的代码会由线程池的线程执行 非阻塞
}
{<!-- -->
Task<long> t = SumAsync();
Console.WriteLine($"Main Thread Task ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
long lResult = t.Result;//访问result 主线程等待Task的完成
t.Wait();//等价于上一行
}
{<!-- -->
Task<int> t = SumFactory();
Console.WriteLine($"Main Thread Task ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
long lResult = t.Result;//没有await和async 普通的task
t.Wait();
}
Console.WriteLine($"Main Thread Task ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
Console.Read();
}
/// <summary>
/// 无返回值 async Task == async void
/// Task和Task<T>能够使用await, Task.WhenAny, Task.WhenAll等方式组合使用。Async Void 不行
/// </summary>
/// <returns></returns>
private static async Task NoReturnTask()
{<!-- -->
//这里还是主线程的id
Console.WriteLine($"NoReturnTask Sleep before await,ThreadId={Thread.CurrentThread.ManagedThreadId}");
Task task = Task.Run(() =>
{<!-- -->
Console.WriteLine($"NoReturnTask Sleep3000 before,ThreadId={Thread.CurrentThread.ManagedThreadId}");
Thread.Sleep(3000);
Console.WriteLine($"NoReturnTask Sleep3000 after,ThreadId={Thread.CurrentThread.ManagedThreadId}");
});
await task;
Console.WriteLine($"NoReturnTask Sleep after await,ThreadId={Thread.CurrentThread.ManagedThreadId}");
}
/// <summary>
/// 带返回值的Task
/// 要使用返回值就一定要等子线程计算完毕
/// </summary>
/// <returns>async 就只返回long</returns>
private static async Task<long> SumAsync()
{<!-- -->
Console.WriteLine($"SumAsync 111 start ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
long result = 0;
await Task.Run(() =>
{<!-- -->
for (int k = 0; k < 10; k++)
{<!-- -->
Console.WriteLine($"SumAsync {k} await Task.Run ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
Thread.Sleep(1000);
}
for (long i = 0; i < 999_999_999; i++)
{<!-- -->
result += i;
}
});
Console.WriteLine($"SumFactory 111 end ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
await Task.Run(() =>
{<!-- -->
for (int k = 0; k < 10; k++)
{<!-- -->
Console.WriteLine($"SumAsync {k} await Task.Run ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
Thread.Sleep(1000);
}
for (long i = 0; i < 999999999; i++)
{<!-- -->
result += i;
}
});
Console.WriteLine($"SumFactory 111 end ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
await Task.Run(() =>
{<!-- -->
for (int k = 0; k < 10; k++)
{<!-- -->
Console.WriteLine($"SumAsync {k} await Task.Run ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
Thread.Sleep(1000);
}
for (long i = 0; i < 999999999; i++)
{<!-- -->
result += i;
}
});
Console.WriteLine($"SumFactory 111 end ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
return result;
}
/// <summary>
/// 真的返回Task 不是async
///
/// 要使用返回值就一定要等子线程计算完毕
/// </summary>
/// <returns>没有async Task</returns>
private static Task<int> SumFactory()
{<!-- -->
Console.WriteLine($"SumFactory 111 start ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
TaskFactory taskFactory = new TaskFactory();
Task<int> iResult = taskFactory.StartNew<int>(() =>
{<!-- -->
Thread.Sleep(3000);
Console.WriteLine($"SumFactory 123 Task.Run ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
return 123;
});
//Console.WriteLine($"This is {iResult.Result}");
Console.WriteLine($"SumFactory 111 end ManagedThreadId={Thread.CurrentThread.ManagedThreadId}");
return iResult;
}
}
