C#中的多线程Thread
C#多线程Thread
Thread .net framework1.0提出的。Thread：是C#对计算机资源线程操作的一个封装类
启动线程的几种方式
可以通过提供委托来启动线程，该委托表示线程在其类构造函数中执行的方法。 然后调用 Start方法开始执行。
线程执行的方法无参数
如果该方法没有参数，则将委托传递给ThreadStart 构造函数。
ThreadStart的签名：
public delegate void ThreadStart()
private static void ThreadStart1() { ThreadStart threadStart = () => { Console.WriteLine("ThreadStartMethod begin...."); }; Thread thread = new Thread(threadStart); thread.Start();//开启一个线程 Console.WriteLine($"ThreadStart线程ID为:{ thread.ManagedThreadId}"); }
线程执行的方法带参数
如果该方法具有参数，则将委托传递 ParameterizedThreadStart给构造函数。
它具有签名：
public delegate void ParameterizedThreadStart(object obj)
/// <summary> /// 带一个参数【Lambda形式的委托】 /// </summary> private static void ParameterizedThreadStart1() { //ParameterizedThreadStart是一个带一个形参的委托 ParameterizedThreadStart method = s => { Console.WriteLine($"ParameterizedThreadStart1传递的参数为{s.ToString()}"); Console.WriteLine($"ParameterizedThreadStart1 thread id={Thread.CurrentThread.ManagedThreadId}"); }; Thread thread = new Thread(method); thread.Start("weiyin1"); } /// <summary> /// 带一个参数[实例化ParameterizedThreadStart委托，委托本质是一个类] /// </summary> private static void ParameterizedThreadStart2() { ParameterizedThreadStart method = new ParameterizedThreadStart(DoSomeThing); Thread thread = new Thread(method); thread.Start("weiyin2"); }
private static void DoSomeThing(object methodname) { Thread.Sleep(1000); Console.WriteLine($"{DateTime.Now.ToString()} method: {methodname},ThreadID=[{Thread.CurrentThread.ManagedThreadId}]"); }
static void Main(string[] args) { ThreadStart1(); ParameterizedThreadStart1(); ParameterizedThreadStart2(); Console.WriteLine($"{DateTime.Now.ToString()} 当前主线程ID为:{Thread.CurrentThread.ManagedThreadId}"); }
Thead线程等待、回调
Thread提供了一系列的方法来操作执行的线程，如下所示：
//thread.Suspend();//暂停线程，微软已弃用 //thread.Resume();//恢复线程，微软已弃用，无法实时的暂停或者恢复线程 //thread.Abort();//终结线程 抛出ThreadAbortException异常，以开始终止此线程的过程 //Thread.ResetAbort();//都会有延时
同时也提供了线程等待的方法，如下：
////如果我们需要线程等待： //1.判断状态等待 //while (thread.ThreadState != ThreadState.Stopped) //{ // Thread.Sleep(200); //} ////2.john等待 //thread.Join();//主线程等待子线程计算完成，卡界面。 ////可以限时等待 //thread.Join(2000);//可以限时等待，等待2s，过时不候 //thread.Priority = ThreadPriority.Highest; ////是不是就可以保证是优先执行呢？不能，其只是提供优先执行的概率，优先执行并不代表优先结束，千万不要用这个来控制线程执行的顺序;
如果我们想要控制线程执行顺序，上面给的thread.Priority = ThreadPriority.Highest;其实不靠谱，那如何实现了？
上篇博客我们提到了回调【一个动作执行完后，顺序执行另一个动作】，此处一样的道理。
1.通过while循环判断子线程的执行状态，当其状态为Stopped时（即子线程执行完毕了）后，执行另一个委托绑定的方法【此处为方便，都写的Lambda表达式】。
此方法虽然可以确保两个委托绑定的方法顺序执行，但是第一个委托执行时，主线程一直在判断其状态，处于卡起的状态，且actionCallBack委托Invoke时线程为主线程。
static void Main(string[] args) { Console.WriteLine($"{DateTime.Now.ToString()} 当前主线程ID为:{Thread.CurrentThread.ManagedThreadId}"); ThreadStart threadStart = () => { Console.WriteLine("threadStart委托开始执行"); Console.WriteLine($"{DateTime.Now.ToString()} 当前threadStart线程ID为:{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine("threadStart委托执行完毕"); }; Action CallBackaction = () => { Console.WriteLine("CallBackaction委托开始执行"); Console.WriteLine($"{DateTime.Now.ToString()} 当前CallBackaction线程ID为:{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine("CallBackaction委托执行完毕"); }; ThreadWithCallBack(threadStart, CallBackaction);
private static void ThreadWithCallBack(ThreadStart threadStart, Action actionCallBack)
{
Thread thread = new Thread(threadStart); thread.Start(); { //主线程会一直while无限循环判断thread子线程的ThreadState状态（卡界面），等待thread子线程其执行完后，在执行后面的动作。 while (thread.ThreadState != ThreadState.Stopped) { Thread.Sleep(1000); } actionCallBack.Invoke(); }
}
2.采用join进行判断，与上面的类似，其也会卡顿主界面。
Thread thread = new Thread(threadStart); thread.Start(); thread.Join();//等待thread子线程执行完毕，其会卡界面 actionCallBack.Invoke();
3 用一个新的委托将这两个顺序执行的委托包起来，然后启动新的线程执行这个新的委托，实现其与主线程异步，但是内部两个委托执行按顺序同步。
//把形参的threadStart和actionCallBack又包了一层。。ThreadStart是一个无参无返回值的委托 //threadStart与actionCallBack的执行是按照先threadStart，后actionCallBack开始的，因为他们包在了 //threadStart1里面是顺序同步的，同时threadStart1子线程与主线程是异步的。实现子线程内部同步按照指定顺序，主线程外面与子线程异步【即不卡界面】，。 //多播委托也可 ThreadStart threadStart1 = new ThreadStart(() => { threadStart.Invoke(); actionCallBack.Invoke(); } ); Thread thread = new Thread(threadStart1); thread.Start();
以上都是无返回值的委托，那如果是执行有返回值的委托呢？
private static void Test() { Func<int> func = () => { return DateTime.Now.Year; }; //int iresult = ThreadWithReturn(func);//能得到2020吗？ Func<int> funcreuslt = ThreadWithReturn<int>(func);//不卡界面 { Console.WriteLine("*******"); Console.WriteLine("这里的执行也需要3秒钟"); } int iresult = funcreuslt.Invoke();//这里会卡界面 }
private static 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();//不卡界面 Console.WriteLine("子线程ID为" + thread.ManagedThreadId); return new Func<T>( () => { thread.Join();// //此处这里写就是想必须等到子线程执行完毕后，才返回拿结果；有可能在这里都不用等待，上面的子线程start都执行完了 Console.WriteLine("Func线程ID为" + Thread.CurrentThread.ManagedThreadId); return t; }); }
注意此处ThreadWithReturn方法的返回值里面：thread.join，其是为了确保thread子线程执行完毕，而进行等待。
结果为：
因为funcreuslt.Invoke()是在主线程的最后面执行的，所以里面委托绑定的方法也是在前面的打印信息之后执行。
Thead线程前台、后台线程
https://www.cnblogs.com/ryanzheng/p/10961777.html
1、当在主线程中创建了一个线程，那么该线程的IsBackground默认是设置为FALSE的。
2、当主线程退出的时候，IsBackground=FALSE的线程还会继续执行下去，直到线程执行结束。
3、只有IsBackground=TRUE的线程才会随着主线程的退出而退出。
4、当初始化一个线程，把Thread.IsBackground=true的时候，指示该线程为后台线程。后台线程将会随着主线程的退出而退出。
5、原理：只要所有前台线程都终止后，CLR就会对每一个活在的后台线程调用Abort（）来彻底终止应用程序。
下面是MSDN给的例子：
例子中创建了两个线程，foregroundThread【IsBackground=false】和backgroundThread [IsBackground=true],foregroundThread线程执行了RunLoop循环打印10次，Background打印50次，当foreground线程执行完后，主线程也执行完毕后，由于设置的backgroundThread
为后台线程，其会随着主线程的退出而退出，而不会继续去执行剩下的逻辑（打印其余次数操作）。
using System; using System.Threading; class Example { static void Main() { BackgroundTest shortTest = new BackgroundTest(10); Thread foregroundThread = new Thread(new ThreadStart(shortTest.RunLoop)); BackgroundTest longTest = new BackgroundTest(50); Thread backgroundThread = new Thread(new ThreadStart(longTest.RunLoop)); backgroundThread.IsBackground = true; foregroundThread.Start(); backgroundThread.Start(); } } class BackgroundTest { int maxIterations; public BackgroundTest(int maxIterations) { this.maxIterations = maxIterations; } public void RunLoop() { for (int i = 0; i < maxIterations; i++) { Console.WriteLine("{0} count: {1}", Thread.CurrentThread.IsBackground ? "Background Thread" : "Foreground Thread", i); Thread.Sleep(250); } Console.WriteLine("{0} finished counting.", Thread.CurrentThread.IsBackground ? "Background Thread" : "Foreground Thread"); } } // The example displays output like the following: // Foreground Thread count: 0 // Background Thread count: 0 // Background Thread count: 1 // Foreground Thread count: 1 // Foreground Thread count: 2 // Background Thread count: 2 // Foreground Thread count: 3 // Background Thread count: 3 // Background Thread count: 4 // Foreground Thread count: 4 // Foreground Thread count: 5 // Background Thread count: 5 // Foreground Thread count: 6 // Background Thread count: 6 // Background Thread count: 7 // Foreground Thread count: 7 // Background Thread count: 8 // Foreground Thread count: 8 // Foreground Thread count: 9 // Background Thread count: 9 // Background Thread count: 10 // Foreground Thread count: 10 // Background Thread count: 11 // Foreground Thread finished counting.
TheadPool线程池
线程池，是在.net framework 2.0提出的，基于Thread做了个升级，Thread功能强大，但是让开发者用不好Thread:框架没有去控制线程数量:容易滥用，就疯狂开启线程数量，其实在开发中，业务处理不好，开线程让服务器扛不住;
池化思想：如果某个对象创建和销毁代价比较高，同时这个对象还可以反复使用的，就需要一个池子，保存多个这样的对象，需要用的时候从池子里面获取；用完之后不用销毁，放回池子。（享元模式）其节约资源提升性能；此外，还能管控总数量，防止滥用。
TheadPool线程池的使用、线程设置
通过将waitCallback委托对象加入到ThreadPool.QueueUserWorkItem来启动一个线程（线程来自于线程池）
/// <summary> /// 线程池 /// 在.net framework 2.0基于Thread做了个升级 /// Thread功能强大，但是让开发者用不好 /// Thread:框架没有去控制线程数量:容易滥用，就疯狂开启线程数量，其实在开发中，业务处理不好，开线程让服务器扛不住; /// 池化思想：如果某个对象创建和销毁代价比较高，同时这个对象还可以反复使用的，就需要一个池子，保存多个这样的对象，需要用的时候从池子 /// 里面获取；用完之后不用销毁，放回池子。（享元模式） /// 节约资源提升性能；此外，还能管控总数量，防止滥用。 /// /// </summary> private static void TreadPoolOperate() { Console.WriteLine("TreadPoolOperate主线程 start"); Console.WriteLine($"主线程ID为：{Thread.CurrentThread.ManagedThreadId}"); //1如何分配一个线程； WaitCallback waitCallback = a => { Console.WriteLine($"waitCallback参数为{a}"); Console.WriteLine("线程池分配的线程ID为：" + Thread.CurrentThread.ManagedThreadId); Console.WriteLine("TreadPoolOperating..."); }; //ThreadPool.QueueUserWorkItem(waitCallback);//无参数 ThreadPool.QueueUserWorkItem(waitCallback, "waitCallback paramInfo");
可以通过ThreadPool提供的API对线程池中线程数目进行相关操作，如下所示：
{ // 2设置线程池中线程数量 //workerThreads: // 线程池中辅助线程的最大数目。 // // completionPortThreads: // 线程池中异步 I/O 线程的最大数目 ThreadPool.SetMinThreads(8, 8); ThreadPool.SetMaxThreads(18, 18);//在之前最大线程不能低于计算机的线程数 //out int minworkTheead 新语法支持引用，相比之前简写了。 ThreadPool.GetMinThreads(out int minworkTheead, out int mincompletionPortThreads); Console.WriteLine($"min this workTheead= {minworkTheead},this completionPortThreads={mincompletionPortThreads}"); ThreadPool.GetMaxThreads(out int maxworkTheead, out int maxcompletionPortThreads); Console.WriteLine($"max this workTheead= {maxworkTheead},this completionPortThreads={maxcompletionPortThreads}"); //线程池里的线程可以设置，但是不要随便折腾，因为设置以后，线程相对于当前线程而言，是全局的 //Task parallel都是来自于线程池。但是new thread由可以新开一个线程,会占用一个线程池的位置 }
ManualResetEvent线程等待
ManualResetEvent被用于在两个或多个线程间进行线程信号发送。 多个线程可以通过调用ManualResetEvent对象的WaitOne方法进入等待或阻塞状态。当控制线程调用Set()方法，所有等待线程将恢复并继续执行。
ManualResetEvent对象的初始化
// // 摘要: // 通知一个或多个正在等待的线程已发生事件。 此类不能被继承。 [ComVisible(true)] public sealed class ManualResetEvent : EventWaitHandle { // // 摘要: // 用一个指示是否将初始状态设置为终止的布尔值初始化 System.Threading.ManualResetEvent 类的新实例。 // // 参数: // initialState: // 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 public ManualResetEvent(bool initialState); }
其构造函数传入一个bool值，如果bool值为False，则使所有线程阻塞，反之，如果bool值为True,则使所有线程退出阻塞。其默认初始值为False
ManualResetEvent mre = new ManualResetEvent(false);
WaitOne方法的使用
该方法阻塞当前线程并等待其他线程发送信号。如果收到信号，它将返回True，反之返回False。以下演示了如何调用该方法。
该方法存在于abstract class WaitHandle类中，是一个虚方法。
API信息如下【其还有很多重载方法，此处不赘述】：
// // 摘要: // 阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号。 // // 返回结果: // 如果当前实例收到信号，则为 true。 如果当前实例永不发出信号，则 System.Threading.WaitHandle.WaitOne(System.Int32,System.Boolean) // 永不返回。 // // 异常: // T:System.ObjectDisposedException: // 已释放当前实例。 // // T:System.Threading.AbandonedMutexException: // 等待结束，因为线程在未释放互斥的情况下退出。 在 Windows 98 或 Windows Millennium Edition 上不会引发此异常。 // // T:System.InvalidOperationException: // 当前实例是另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。 public virtual bool WaitOne();
Set方法
该方法用于给所有等待线程发送信号。 Set() 方法的调用使得ManualResetEvent对象的bool变量值为True，所有线程被释放并继续执行。
Reset方法
一旦我们调用了ManualResetEvent对象的Set()方法，它的bool值就变为true,我们可以调用Reset()方法来重置该值，Reset()方法重置该值为False。
此处初始化了一个值为False的ManualResetEvent对象，这意味着所有调用WaitOne的线程将被阻塞【此例主线程调用了WaitOne】，直到有线程调用了 Set() 方法【此处子线程语句最后将事件信号状态变为了True,主线程WaitOne就能继续执行，而不用等待了】。
private static void TreadPoolOperate() { Console.WriteLine("TreadPoolOperate主线程 start"); Console.WriteLine($"主线程ID为：{Thread.CurrentThread.ManagedThreadId}");
//3线程等待：观望式 //ManualResetEvent默认要求参数状态为false--mre.set();打开 //ManualResetEvent 参数状态为true->open-->mre.reset();关闭 ManualResetEvent mre = new ManualResetEvent(false);//如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止 ThreadPool.QueueUserWorkItem(a => { Console.WriteLine(a); Console.WriteLine("当前子线程ID为" + Thread.CurrentThread.ManagedThreadId); Console.WriteLine("线程池里面的线程执行完毕"); //将事件状态设置为有信号，从而允许一个或多个等待线程继续执行。 mre.Set();//信号由false变为true }); Console.WriteLine("do something else"); Console.WriteLine("do something else"); Console.WriteLine("do something else"); //// 阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号。 mre.WaitOne();//判断信号，没有信号（为false），继续等起，有信号了（mre.Set()后，信号为true）,不用等待了，可以往后执行了
//只要mre的状态变为true,则继续往后执行 Console.WriteLine("全部任务执行完成");
而如果我们用值True来对ManualResetEvent对象进行初始化，所有调用WaitOne方法的线程并不会被阻塞，可以进行后续的执行。
Thead、TheadPool扩展封装
那如果初始状态设置为无信号，后面又执行WaitOne无限等待，那就会出现死锁的状态。如下例所示：
#region myregion { ThreadPool.SetMaxThreads(32, 32);// ManualResetEvent mre1 = new ManualResetEvent(false); for (int i = 0; i < 32; i++) { int k = i; ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($"thread ID={Thread.CurrentThread.ManagedThreadId}"); }); if (k == 31) { mre1.Set(); } else { mre1.WaitOne();//死锁了 Console.WriteLine("mre1.WaitOne()"); } } mre1.WaitOne(); Console.WriteLine("所有任务执行完成"); } #endregion
