20181104_C#线程之Thread_ThreadPool_使用Thread实现回到和带参数的回调

C#   .net  Framework多线程演变路径:

1.0    1.1 时代使用Thread

2.0    时代使用ThreadPool

3.0    时代使用Task

4.0    时代使用Parallel

4.5 时代使用 async/awit

一.   DoSomethingLong方法如下:

/// <summary>
        /// 一个比较耗时耗资源的私有方法
        /// </summary>
        /// <param name="name"></param>
        private void DoSomethingLong(string name)
        {
            Console.WriteLine($"****************DoSomethingLong {name} Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
            long lResult = 0;
            for (int i = 0; i < 1000000000; i++)
            {
                lResult += i;
            }
            //Thread.Sleep(2000);

            Console.WriteLine($"****************DoSomethingLong {name}   End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}***************");
        }

二.   使用Thread

a)         下面代码演示, 如何使用Thread来启动一个线程

 //public Thread(ThreadStart start, int maxStackSize);  //maxStackSize 表示指定这个线程最大可以使用多少内存空间, 一般不用设置
            ThreadStart threadStart = () => this.DoSomethingLong("btnThreads_Click");
            Thread thread = new Thread(threadStart);
thread.Start();

　b) Thread的一些其它api

i.	thread.Suspend();//(弃用)线程挂起, 使线程暂停执行; 已过期, 不推荐使用, 会导致死锁, 因为线程的执行的时候, 是会占用资源的, 虽然手动让线程暂停执行了, 但是它占用的资源是不会释放的
ii.	thread.Resume();//(弃用)唤醒线程, 使挂起的线程重新开始执行, 和Suspend()对应
iii.	thread.Abort(); //线程终止
            try
            {
                thread.Abort();//销毁，方式是抛异常   也不建议再使用    不一定及时/有些动作发出收不回来(比如子线程向数据库发出一个查询命令, 此时命令已经发出, 但是数据库还没有返回来值, 但是主线程强制子线程停止了, 然后数据库返回来的值就没有人接收了)
                //就像你正在跑步, 人后旁边有人说停; 你从听到停, 到真正的停下来, 还是处于跑的状态
               // 使用abort一定要使用try catch来处理
            }
            catch (Exception)
            {
                //
                Thread.ResetAbort();//取消Abort异常, 然后继续计算
            }

            //线程等待
iv.	thread.Join();//当前线程等待thread完成, 当前线程就是谁执行这句话, 谁就是当前线程, 在这里当前线程就是主线程了, 因为主线程在执行这句话
            thread.Join(500);//最多等500; 当前线程等待500毫秒
            Console.WriteLine("等待500ms");

            // ThreadState.Running //启动线程
            while (thread.ThreadState != ThreadState.Stopped)
            {
                Thread.Sleep(100);//当前线程 休息100ms
            }
v.	关于jion和sleep
            //jion是实实在在的等待, 占据cpu;  像上面的示例, thread.jion(500), 那么这个时候, 其实thread还是在做自己的事情. jion就会在这里等一段时间(或者等thread把活干完); 此时是有两个线程并发运行的; 一个thread的线程, 一个jion的线程
            //sleep表示睡眠, 把当前线程的上下文保存着, 把cpu的时间片交出去, cpu可以去处理其他事情

vi.	前台线程和后台线程的区别
            ////Console.WriteLine(thread.IsBackground);
            ////默认是前台线程，启动之后一定要完成任务的，阻止进程退出; 也就是说, 就算你的应用程序被关闭了, 但是前台线程还是要坚持把它的事情做完之后才会停止自己
            ////thread.IsBackground = true;//指定后台线程：随着进程退出, 也就是说程序关闭后, 后台线程也停止了

vii.	线程优先级:
           thread.Priority = ThreadPriority.Highest;//线程优先级
 ////CPU会优先执行标记为Highest的线程,    但是并不代表说Highest就一定最先把事情处理完, 只能说CPU会优先为这个线程分配时间片

三.   使用ThreadPool

a)         推出ThreadPool的原因:

i.	在thread中提供了太多的API, 又是挂起, 又是终止, 又是休眠, 又是优先级, 各种各样乱七八糟, 但是又不是真真正正的真的能准确的操控
ii.	于是就到2.0之后,Thread就被替换成了ThreadPool, 把所有的该简化的都简化了,什么API都没有了. 也没有销毁, 也没有挂起, 更没有暂停; 但是也可以将线程进行重用, 避免重复的创建和销毁, 线程被使用完之后, 会放回池子, 下次继续使用

b)         使用线程池ThreadPool的方式启动多线程, 代码如下:

//池→容器; 线程池就是线程的容器, 当在一个系统中, 反复的使用不同的资源的时候, 但是这些资源使用完需要二次创建(销毁)的成本太高的时候, 就要考虑使用池技术
            //池技术就是享元模式的精华
            //QueueUserWorkItem队列用户工作项, 将用户的工作项, 放入到队列汇总
            //QueueUserWorkItem从线程池的方式来启动多线程; 这可能是启动多线程最简单的一种方式了
            ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));
            ThreadPool.QueueUserWorkItem(t => this.DoSomethingLong("btnThreadPool_Click"));

c)         设置/获取 ThreadPool中最大和最小线程数量:

 {
                //对线程加以限制 workerThreads→线程池中最大的工作线程数据
                //workerThreads →线程池中的最大线程数, 这个是工作线程, 平时启动的线程一般都是基于工作线程的, 如果超过了将会被排队
                //completionPortThreads表示线程池中异步i/o线程的最大数目
                ThreadPool.GetMaxThreads(out int workerThreads, out int completionPortThreads);
                Console.WriteLine($"GetMaxThreads workerThreads={workerThreads} completionPortThreads={completionPortThreads}");
            }
            {
                //线程池内最小线程数; 默认情况下, 最小的线程数, 好像是跟CPU有关; 比如4核8线程的, 那么这里就是8和8; 我的就是4和4
                ThreadPool.GetMinThreads(out int workerThreads, out int completionPortThreads);
                Console.WriteLine($"GetMinThreads workerThreads={workerThreads} completionPortThreads={completionPortThreads}");
            }
            // 有get就有set 设置最大线程数  ThreadPool的最大线程数也会影响这Task的线程
            ThreadPool.SetMaxThreads(16, 16);
            // 设置最小线程数
            ThreadPool.SetMinThreads(8, 8); //实际操作来看, 最小的会受到影响
            //设置完成后, 再次打印一次
            {
                ThreadPool.GetMaxThreads(out int workerThreads, out int completionPortThreads);
                Console.WriteLine($"GetMaxThreads workerThreads={workerThreads} completionPortThreads={completionPortThreads}");
            }
            {
                ThreadPool.GetMinThreads(out int workerThreads, out int completionPortThreads);
                Console.WriteLine($"GetMinThreads workerThreads={workerThreads} completionPortThreads={completionPortThreads}");
            }

　

d)         在ThreadPool中实现线程等待

////ThreadPool啥API都没有, 那么如何在ThreadPool中等待线程完成才往下执行呢?
            // 可以使用 ManualResetEvent(手动重启事件)类, 这个类包含了一个bool属性, 如果在初始化这个类的时候, 将其初始化为false, 则这个类实例的的WaitOne()方法将会被阻塞, 一直阻塞, 直到他的bool属性变成true;   当然, 可以通过ManualResetEvent的set方法使其变成 true ; 当然这里也可以自己定义一个变量来实现, 但是ManualResetEvent是线程安全的
            // false--WaitOne等待--Set--true--WaitOne直接过去
            // true--WaitOne直接过去--ReSet--false--WaitOne等待
            ManualResetEvent manualResetEvent = new ManualResetEvent(false); //初始化ManualResetEvent类中的变量为false
            ThreadPool.QueueUserWorkItem(t =>
            {
                Console.WriteLine("即将开始执行DoSomethingLong函数");
                this.DoSomethingLong("btnThreadPool_Click");
                Console.WriteLine("执行DoSomethingLong函数完毕");
                manualResetEvent.Set(); //将信号设置为true
                //manualResetEvent.Reset(); //将信号设置为false
            });
             manualResetEvent.WaitOne(); //阻塞当前线程; 如果当前manualResetEvent在主线程创建的, 那么就会阻塞主线程  但是要注意一般来说，不要阻塞线程池的线程

　　

四.    使用Thread完成回调和带返回值的回调

a)         使用Thread完成回调, 代码如下:

 /// <summary>
        /// 演示线程的回调; 启动子线程计算--完成委托后，该线程去执行后续回调委托 ;
        /// </summary>
        /// <param name="act">第一个委托是你真的想要执行的这个方法</param>
        /// <param name="callback">第二委托是当你执行完第一个方法之后, 想要执行的回调, 其实就是在一个线程内将两个方法并列执行了一次</param>
        private void ThreadWithCallback(Action act, Action callback)
        {
            Thread thread = new Thread(() =>
            {
                act.Invoke();
                callback.Invoke();
            });
            thread.Start();
        }

　调用方法如下:

 private void btnThreads_Click(object sender, EventArgs e)
        { 

            this.ThreadWithCallback(() => Console.WriteLine($"这里是action  {Thread.CurrentThread.ManagedThreadId.ToString("00")}")
                               , () => Console.WriteLine($"这里是callback  {Thread.CurrentThread.ManagedThreadId.ToString("00")}"));
        }

　

b)         使用Thread完成带返回值的回调, 代码如下:

/// <summary>
        /// 带返回值的异步调用;     带返回的异步调用  需要获取返回值 (会卡界面的)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        private Func<T> ThreadWithReturn<T>(Func<T> func)
        {
            #region 错误的写法

            //T t ;
            //Thread thread = new Thread(() =>
            //{
            //    t = func.Invoke(); //这里还没有执行的时候, 它已经返回了
            //});
            //thread.Start();
            //  return t;

            #endregion

            T t = default(T);
            Thread thread = new Thread(() =>
            {

                t = func.Invoke();
            });
            thread.Start();
            return () =>
            {
               // while (thread.ThreadState != ThreadState.Stopped) { Thread.Sleep(200); }
                thread.Join();
                return t;
            };
        }

　

调用方法如下:

private void withReturn_Click(object sender, EventArgs e)
        {

            Func<int> func = this.ThreadWithReturn<int>(() =>
            {
                Thread.Sleep(2000);
                return DateTime.Now.Millisecond;
            });
            Console.WriteLine("上面是异步调用, 直接就会打印这句话, 这句话不会等待2秒");

            int iResult = func.Invoke();
            Console.WriteLine(iResult);
        }