Shulou(Shulou.com)06/02 Report--

This article mainly explains "how to use C# asynchronous multithreaded ThreadPool". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "how to use C# asynchronous multithreaded ThreadPool".

Start a thread pool thread

ThreadPool provides less API than Thread. In ThreadPool, you need to use the QueueUserWorkItem method to start a thread.

For example, Dosome is a common method. Pass in the QueueUserWorkItem method to start a new thread to execute this method.

Public static void Dosome () {Console.WriteLine ($"Task Start ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}");} static void Main (string [] args) {Console.WriteLine ($"Main method start, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); ThreadPool.QueueUserWorkItem (x = > Dosome ()) Console.WriteLine ($"Main method ends, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Console.ReadLine ();}

When you start the thread, you can see that a new child thread 3 is opened to execute the task, while the main thread 1 does not wait for child thread 3

Number of threads in the thread pool

In the era of Thread, there is no concept of the number of threads. In the era of ThreadPool 2.0, the number of threads in the thread pool can be set by SetMaxThreads and SetMaxThreads methods. You can also check the number of threads in the thread pool to obtain the minimum and maximum number of threads in the thread pool through the GetMinThreads and GetMaxThreads methods.

Note: it is generally not recommended to set the number of ThreadPool threads, this operation is global. In the second case, when the thread pool is exhausted, it will cause a deadlock.

For example: to manipulate the view thread through SetMaxThreads, SetMaxThreads, GetMinThreads, GetMaxThreads methods

{ThreadPool.GetMinThreads (out int workerThreadsMin, out int completionPortThreadsMin); / / worker thread, io thread Console.WriteLine ($"[default] minimum workerThreadsMin: {workerThreadsMin} completionPortThreadsMin: {completionPortThreadsMin}"); ThreadPool.GetMaxThreads (out int workerThreadsMax, out int completionPortThreadsMax); / / worker thread Console.WriteLine ($"[default] maximum workerThreadsMax: {workerThreadsMax} completionPortThreadsMax: {completionPortThreadsMax}");} ThreadPool.SetMinThreads (3,3) / / setting 4 is actually not 4, it should be a logical eight-core machine, at least this ThreadPool.SetMaxThreads (7,7); {ThreadPool.GetMinThreads (out int workerThreadsMin, out int completionPortThreadsMin); / / worker thread, io thread Console.WriteLine ($"[custom] minimum workerThreadsMin: {workerThreadsMin} completionPortThreadsMin: {completionPortThreadsMin}"); ThreadPool.GetMaxThreads (out int workerThreadsMax, out int completionPortThreadsMax) / / worker thread, io thread Console.WriteLine ($"[Custom] maximum workerThreadsMax: {workerThreadsMax} completionPortThreadsMax: {completionPortThreadsMax}");} ThreadPool.SetMinThreads (5,5); / / setting 4 is actually not 4, it should be a logical eight-core machine, and the minimum is this ThreadPool.SetMaxThreads (16,16); {ThreadPool.GetMinThreads (out int workerThreadsMin, out int completionPortThreadsMin) / / worker thread, io thread Console.WriteLine ($"[custom] minimum workerThreadsMin: {workerThreadsMin} completionPortThreadsMin: {completionPortThreadsMin}"); ThreadPool.GetMaxThreads (out int workerThreadsMax, out int completionPortThreadsMax); / / worker thread, io thread Console.WriteLine ($"[custom] maximum workerThreadsMax: {workerThreadsMax} completionPortThreadsMax: {completionPortThreadsMax}");}

Thread pool thread waiting

Looking at the previous explanation related to ThreadPool, some partners may find that we have not talked about waiting threads, so does ThreadPool have any relevant API? Answer: no

However, thread waiting can be implemented through ManualResetEvent. Generally speaking, thread waiting is not recommended, nor is it recommended in two cases. Because in the thread pool, the number of threads is limited, the thread waiting caused by writing code is not released inadvertently, once the thread pool thread is exhausted, it will form a deadlock. Unless you have to wait for the situation, be sure to release the wait and check the code.

For example, if the thread waits, the ManualResetEvent is initialized to false,Set () and the true,WaitOne () method is set to check whether the ManualResetEvent object is true. If not, it will wait all the time. If it is true, it will be passed directly.

Public static void Dosome () {Console.WriteLine ($"Task Start ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Thread.Sleep (5 * 1000); / / Simulation task time Console.WriteLine ($"Task End ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}") } static void Main (string [] args) {Console.WriteLine ($"Main method starts, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); ManualResetEvent manualResetEvent = new ManualResetEvent (false); ThreadPool.QueueUserWorkItem (x = > {Dosome (); manualResetEvent.Set (); / / will become true}); manualResetEvent.WaitOne () Console.WriteLine ($"Main method ends, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Console.ReadLine ();}

When you start the program, you can see that after the main thread 1 waits for the child thread 3 to complete the execution, the end code of the Main method is executed

For example, thread exhaustion forms a deadlock, and the number of threads in the thread pool is first limited to a maximum of 10 threads. Then we start 18 threads to work in a loop and let the first 18 threads wait.

Console.WriteLine ($"Main method start, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); ThreadPool.SetMinThreads (4,4); ThreadPool.SetMaxThreads (10,10); ThreadPool.GetMinThreads (out int workerThreadsMin, out int completionPortThreadsMin); / / worker thread, io thread Console.WriteLine ($"[custom] minimum workerThreadsMin: {workerThreadsMin} completionPortThreadsMin: {completionPortThreadsMin}"); ThreadPool.GetMaxThreads (out int workerThreadsMax, out int completionPortThreadsMax) / / worker thread, io thread Console.WriteLine ($"[Custom] maximum workerThreadsMax: {workerThreadsMax} completionPortThreadsMax: {completionPortThreadsMax}"); ManualResetEvent manualResetEvent = new ManualResetEvent (false); for (int I = 0; I

< 20; i++) { int k = i; ThreadPool.QueueUserWorkItem((x) =>

{Console.WriteLine (k); if (k)

< 18) { manualResetEvent.WaitOne(); } else { manualResetEvent.Set(); } }); } manualResetEvent.WaitOne(); Console.WriteLine($"Main 方法结束，ThreadId：{Thread.CurrentThread.ManagedThreadId}，DateTime：{DateTime.Now.ToLongTimeString()}"); Console.ReadLine(); 启动程序，可以看到，当开启 10 个线程后，程序就已经不再运行了。这是当程循环开启第 11 个子线程时，发现线程池里面没有线程了，就会一直等待，这样一个状态就是死锁。 线程回调 讲到现在，细心的小伙伴会发现一直没有说线程回调，即当子线程执行一个任务完成后，再执行一个任务。其实 Thread 与 ThreadPool 都没有回调，但是可以创造出 Callback，那就是包一层，如果不行那就再包一层。 Thread 例如：创建一个普通方法 ThreadWithCallback 传入两个委托参数，一个实际任务，一个 Callback。接着在内部使用 Thread 开启一个新的线程，执行 action、callback 方法。 private static void ThreadWithCallback(Action action, Action callback){ Thread thread = new Thread(() =>

{action.Invoke (); callback.Invoke ();}); thread.Start ();} static void Main (string [] args) {Console.WriteLine ($"Main method start, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); ThreadWithCallback () = > {Console.WriteLine ($"action,ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}") }, () = > {Console.WriteLine ($"callback,ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Console.WriteLine ($"Main method ends, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Console.ReadLine ();}

When you start the program, you can see that callback has been executed after action has been executed.

ThreadPool

For example: create a normal method ThreadWithCallback and pass in two delegate parameters, an actual task and a Callback. Then start a new thread internally using ThreadPool to execute the action, callback methods.

Private static void ThreadWithCallback (Action action, Action callback) {ThreadPool.QueueUserWorkItem (x = > {action.Invoke (); callback.Invoke ();});} static void Main (string [] args) {Console.WriteLine ($"Main method start, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}") ThreadWithCallback (() = > {Console.WriteLine ($"action,ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}");}, () = > {Console.WriteLine ($"callback,ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}");}) Console.WriteLine ($"Main method ends, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Console.ReadLine ();}

When you start the program, you can see that callback has been executed after action has been executed.

Thread return value

Up to now, careful buddies will find that there is no thread return value all the time, and Thread and ThreadPool do not provide relevant API in the 1.0,2.0 era. But it can be created, or wrap one layer, if not, then wrap another layer.

Thread

For example: create a common method ThreadWithReturnCallback return and input parameters are both Func

< T >

Internally enable a Thread to execute a delegate, return a delegate with a return value and a thread of Thread waiting to be placed inside. When you use it, you can pass a delegate with a return value to the ThreadWithReturnCallback method, because the return value of the ThreadWithReturnCallback method is also a delegate, so you need to Invoke externally to get the result, and this Invoke operation will card the main thread.

Private static Func ThreadWithReturnCallback (Func func) {T t = default (T); Thread thread = new Thread (() = > {t = func.Invoke ();}); thread.Start (); return () = > {thread.Join (); return t;} } static void Main (string [] args) {Console.WriteLine ($"Main method starts, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Func func = ThreadWithReturnCallback (() = > {return DateTime.Now.Millisecond;}); int iResult = func.Invoke (); Console.WriteLine (iResult) Console.WriteLine ($"Main method ends, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Console.ReadLine ();}

ThreadPool

For example: create a common method ThreadPoolWithReturnCallback return and input parameters are both Func

< T >

Use the QueueUserWorkItem method to start the thread to execute the delegate, because ThreadPool itself does not provide a thread wait method, so here use ManualResetEvent for thread waiting, return a delegate with a return value, and the ManualResetEvent WaitOne thread waits to be placed inside. When you use it, you can pass a delegate with a return value to the ThreadPoolWithReturnCallback method, because the return value of the ThreadPoolWithReturnCallback method is also a delegate, so you need to Invoke externally to get the result, and this Invoke operation will card the main thread.

Private static Func ThreadPoolWithReturnCallback (Func func) {T t = default (T); ManualResetEvent manualResetEvent = new ManualResetEvent (false); ThreadPool.QueueUserWorkItem (x = > {t = func.Invoke (); manualResetEvent.Set (); / / will become true}); return () = > {manualResetEvent.WaitOne (); return t;} } static void Main (string [] args) {Console.WriteLine ($"Main method starts, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Func func = ThreadPoolWithReturnCallback (() = > {return DateTime.Now.Millisecond;}); int iResult = func.Invoke (); Console.WriteLine (iResult) Console.WriteLine ($"Main method ends, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}"); Console.ReadLine ();}

Thread pool thread reuse

In era 1.0, Thread applied to the operating system for threads every time it created an instance, and ThreadPool in era 2.0 used QueueUserWorkItem to fetch threads from the thread pool, not to the operating system. Therefore, using ThreadPool to create threads is more efficient than Thread.

For example, we start three waves of threads to execute tasks and perform the same tasks.

Static void Main (string [] args) {Console.WriteLine ($"Main method starts, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()}\ n"); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($"Zhang San), task processing is complete. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Li Si, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Wang Wu, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($"), the task is completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); Thread.Sleep (1000); Console.WriteLine (); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Zhang San, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Li Si, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Wang Wu, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($"), the task is completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); Thread.Sleep (1000); Console.WriteLine (); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Zhang San, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Li Si, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($" Wang Wu, task processing completed. ThreadId: {Thread.CurrentThread.ManagedThreadId} ");}); ThreadPool.QueueUserWorkItem (t = > {Console.WriteLine ($"), the task is completed. ThreadId: {Thread.CurrentThread.ManagedThreadId}\ n ");}); Thread.Sleep (1000); Console.WriteLine ($" Main method ends, ThreadId: {Thread.CurrentThread.ManagedThreadId}, DateTime: {DateTime.Now.ToLongTimeString ()} "); Console.ReadLine ();}

Start the program, the first wave enabled 3, 4, 6, 7, the second wave reused the first wave 6, 7, the third wave reused the first wave, the second wave 3, 4, 5, 8. What is not reused is that the thread is not reclaimed (recycling takes time), so it is not reused.

Extended knowledge-delegate thread

The delegated BeginInvoke method uses threads from the thread pool, and the child threads will not be reclaimed immediately after the task is executed, unless the call to EndInvoke can immediately end the child threads and return to the thread pool, which is conducive to thread reuse.

For example, BeginInvoke threads cannot be immediately recycled and reused

Static void Main (string [] args) {Action action = x = > {Console.WriteLine ($"I am {x}, Thread: {Thread.CurrentThread.ManagedThreadId}");}; for (int I = 0; I

< 5; i++) { action.BeginInvoke(i,null,null); } Console.ReadLine();} 启动线程，并发五次，分别启用了4、5、7、8、9，五个线程 例如：EndInvoke 线程更好重用，BeginInvoke 方法的第二个参数 static void Main(string[] args){ Action action = x =>

{Console.WriteLine ($"I am {x}, Thread: {Thread.CurrentThread.ManagedThreadId}");}; for (int I = 0; I

< 5; i++) { action.BeginInvoke(i, e =>

{action.EndInvoke (e);}, null);} Console.ReadLine ();}

When you start the program, you can see that the concurrency is only used 5 times, threads 3 and 8.

Thank you for your reading, the above is the content of "how to use C# asynchronous multithreaded ThreadPool". After the study of this article, I believe you have a deeper understanding of how to use C# asynchronous multithreaded ThreadPool, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.