.net 多线程 Thread ThreadPool Task

先准备一个耗时方法
/// <summary>
/// 耗时方法
/// </summary>
/// <param name="name"></param>
private void DoSomeThing(string name)
{
                 Console.WriteLine($"开始执行{name}, {Thread.CurrentThread.ManagedThreadId.ToString("00")} ,{DateTime.Now}");
                 int num = 1;

                 for (int i = 0; i < 100000000; i++)
                 {
                                 num++;
                 }
                 Thread.Sleep(1000);

              Console.WriteLine($"结束执行{name}, {Thread.CurrentThread.ManagedThreadId.ToString("00")} ,{DateTime.Now},{num}");
}
 
 
.net Framework框架1.0和1.1时期,多线程,用Thread
 
ThreadStart  threadStart = new ThreadStart(()=>this.DoSomeThing("Thread"));
Thread thread = new Thread(threadStart);
thread.Start();// 开始执行多线程任务了。
 
//thread.Start();默认是前台线程,UI退出后,还是会继续执行完,如果thread.IsBackgroud=true;//就变成主线程关闭就直接关闭了
 
thread.Join();//这个方法是让主线程等着当前线程完成之后再执行
 
thread.Suspend();//暂停  过时方法不推荐
thread.Resume();//重启  过时方法不推荐
thread.Abort();//销毁  过时方法不推荐
 
基于Thread封装一个支持回调
private void ThreadWithCallback(ThreadStart threadStart  Action callback)
{
          ThreadStart  startNew = new ThreadStart(
                  ()=>
                     {
                             threadStart.Invoke();//执行传入的线程方法
                             callback.Invoke(); //执行回调函数
                     } 
             );
          Thread thread = new Thread(startNew);
           thread.Start();
}
 
调用这个方法:
ThreadStart threadStart = new ThreadStart(() => this.DoSomeThing("Thread"));
 Action callback = () => Console.WriteLine("这是回调函数");
 
this.ThreadWithCallback(threadStart , callback );
 
 
/// <summary>
/// 基于Thread封装带返回的
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="funcT"></param>
/// <returns></returns>
private Func<T> ThreadWithReturn<T>(Func<T> funcT)
{
           T t = default(T);

            ThreadStart startNew = new ThreadStart(()=> {
            t = funcT.Invoke();
            });
            Thread thread = new Thread(startNew);
            thread.Start();
            return new Func<T>(()=> 
            {
                thread.Join();
                return t;
             });
}
 
调用这个方法
{
Func<int> func = this.ThreadWithReturn(() => 222);

Console.WriteLine( func.Invoke());

}
 
.net Framework框架2.0时期,多线程,用ThreadPool
 
ThreadPool.QueueUserWorkItem(o=>
{
          Thread.sleep(2000);
           this.DosomeThing("ThreadPool");
} //这个就是开启一个子线程。
 
如果要控制等待,就用
 ManualResetEvent mre = new ManualResetEvent(false);//默认填false
ThreadPool.QueueUserWorkItem(o => {
            Thread.Sleep(2000);
            this.DoSomeThing("ThreadPool");
            mre.Set();//这个设置之后
});
            mre.WaitOne();//当mre.Set之后,主线程就可以等待子线程执行完成之后再执行
             
            Console.WriteLine($"this is end ");
 
.net Framework框架3.0时期,多线程,用Task
 
Task.Run(()=>this.DoSomeThing("task")); //就开启执行子线程了
 
推荐使用Task的原因:1.使用的是线程池的线程,全部都是后台线程
                                    2、Api很强大
 
TaskFactory taskFactory = Task.Factory();
taskFactory.StartNew(()=>this.DoSomeThing("task1"));//跟Task.Run的效果一样
taskFactory.StartNew(()=>this.DoSomeThing("task2"));
taskFactory.StartNew(()=>this.DoSomeThing("task3"));
taskFactory.StartNew(()=>this.DoSomeThing("task4"));
taskFactory.StartNew(()=>this.DoSomeThing("task5"));//执行多个子线程
 
需要多线程加快速度,同时又要求全部完成后,执行新的任务
多业务操作希望并发,但是全部完成后,执行新的任务
 
List<Task> tkList = new List<Task>();
 
tkList.Add(taskFactory.StartNew(()=>this.DoSomeThing("task1")));
tkList.Add(taskFactory.StartNew(()=>this.DoSomeThing("task2")));
tkList.Add(taskFactory.StartNew(()=>this.DoSomeThing("task3")));
 
Task.WaitAll(tkList.toArray());
ConSole.WriteLine("全部完成之后,执行任务");
 
 
需要多线程加快速度,同时又要求一个任务完成后,执行新的任务
多业务操作希望并发,但是一个任务完成后,执行新的任务
Task.WaitAny(tkList.toArray());
ConSole.WriteLine("一个任务完成之后,执行任务");
 
不过两个方法同时使用的时候,WaitAny放在WaitAll前面。
 
但是上面2个方法都会卡住UI界面
 
还有2个方法也可以执行同样的任务,而且不卡界面,类似回调
 
taskFactory.ContinueWhenAll(tasks.ToArray(), tList => { Console.WriteLine("全部执行完之后执行,而且不卡界面"); });
 
taskFactory.ContinueWhenAny(tasks.ToArray(), t => { Console.WriteLine("执行一个任务后,执行,不卡界面"); });
 
4种方法可以一起使用,如果想先执行不卡界面的方法,后执行Task.WaitAll的方法,就可以先把这2个方法也添加进集合里面
tasks.Add(taskFactory.ContinueWhenAll(tasks.ToArray(), tList => { Console.WriteLine("全部执行完之后执行,而且不卡界面"); }));

tasks.Add(taskFactory.ContinueWhenAny(tasks.ToArray(), t => { Console.WriteLine("执行一个任务后,执行,不卡界面"); }));
 
Task.WaitAny(tkList.toArray());
ConSole.WriteLine("一个任务完成之后,执行任务");
Task.WaitAll(tkList.toArray());
ConSole.WriteLine("全部完成之后,执行任务");
 
 
可以给每个子线程,取一个标识

Task tack= taskFactory.StartNew(t => Console.WriteLine("新的一个任务"),"标识Token"); //设置标识
Console.WriteLine(tack.AsyncState.ToString());//获取标识并且打印 tack.AsyncState
 
获取返回值
//Task<int> task = taskFactory.StartNew(()=>123456);
//int result = task.Result;
//Console.WriteLine(result);
 
 
一个线程执行后马上执行另一个
taskFactory.StartNew(t=>this.DoSomeThing("第一个方法")).ContinuWith(t=>ConSole.WriteLine("第二个"))
 
 
 
posted @ 2019-02-24 23:23  H哥努力啊  阅读(652)  评论(0编辑  收藏  举报