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

This article mainly shows you "how to use C# multithreading", the content is easy to understand, clear, hope to help you solve doubts, the following let the editor lead you to study and learn "how to use C# multithreading" this article.

1. Basic concepts 1. Process

First open the Task Manager to view the currently running processes:

You can see all the currently running processes from the Task Manager. So what on earth is process?

Process is a basic concept in Windows system, which contains the resources needed to run a program. A running application is treated as a process in the operating system, and the process can include one or more threads. Threads are the basic unit in which the operating system allocates processor time, and multiple threads can execute code at the same time in a process. Processes are relatively independent, one process cannot access the data of another process (unless using distributed computing), and the failure of one process will not affect the operation of other processes. Windows system uses processes to divide the work into multiple independent areas. A process can be understood as the basic boundary of a program. Is a running routine of the application, is a dynamic execution process of the application.

2. Thread

Query the total number of threads currently running in the task manager:

Thread is the basic execution unit of a process and the basic unit of CPU time allocated by the operating system. A process can contain several threads, and the first thread executed at the process entrance is regarded as the main thread of the process. In .NET applications, the Main () method is used as the entry, and when this method is called, the system automatically creates a main thread. Threads are mainly composed of CPU registers, call stacks and thread local memory (Thread Local Storage,TLS). The CPU register mainly records the status of the current executing thread, the call stack is mainly used to maintain the memory and data called by the thread, and the TLS is mainly used to store the state information of the thread.

Second, multithreading

The advantages of multithreading: you can complete multiple tasks at the same time; you can make the program respond faster; you can make tasks that take up a lot of processing time or tasks that are not currently being processed give processing time to other tasks on a regular basis; you can stop tasks at any time; you can set the priority of each task to optimize program performance.

Then some people may ask: why can multithreaded execution? To sum up, there are two reasons:

1. The running speed of CPU is too fast, and the hardware processing speed can not keep up with it, so the operating system is managed by time slices. In this way, it is multithreaded concurrently from a macro point of view, because CPU is too fast to detect, and it seems that different operations are being performed at the same time. But from a micro point of view, only one thread can process it at a time.

2. At present, computers are multi-core and multi-CPU. A CPU can only run one thread at a time, but multiple CPU can run multiple threads at the same time.

However, although multithreading has many advantages, it must be recognized that multithreading may have disadvantages that affect system performance in order to use threads correctly. The main disadvantages are as follows:

(1) Threads are also programs, so threads need to take up memory, and the more threads, the more memory.

(2) Multithreading needs to be coordinated and managed, so it takes up CPU time to track threads.

(3) the access to shared resources between threads will influence each other, so the problem of contention for shared resources must be solved.

(4) too many threads will lead to too complex control, which may eventually lead to many program defects.

When you start an executable program, a main thread is created. By default, a C # program has a thread that executes code in the program that starts and ends with the Main method, and every command executed directly or indirectly by the Main () method is executed by a default thread (the main thread), which terminates when the Main () method returns.

A process can create one or more threads to execute part of the program code associated with the process. In C #, threads are handled using the Thread class, which is in the System.Threading namespace. When you create a thread using the Thread class, you only need to provide a thread entry, which tells the program what to do with the thread. You can create a thread by instantiating an object of the Thread class. When you create a new Thread object, a new managed thread is created. The Thread class receives a ThreadStart delegate or the constructor of a ParameterizedThreadStart delegate that wraps the method called by the new thread when the Start method is called. The sample code is as follows:

Thread thread=new Thread (new ThreadStart (method)); / / create thread thread.Start (); / / start thread

The above code instantiates a Thread object, indicates the method method () to be called, and then starts the thread. The method as a parameter in the ThreadStart delegate does not require a parameter and does not return a value. ParameterizedThreadStart delegates an object as a parameter, which can be easily passed to the thread. The sample code is as follows:

Thread thread=new Thread (new ParameterizedThreadStart (method)); / / create thread thread.Start (3); / / start thread

To create multithreading:

1. Write the method to be executed by the thread

2. Instantiate the Thread class and pass in a delegate that points to the method that the thread wants to execute. (by this time the thread has been generated, but has not yet run)

3. Call the Start method of the Thread instance to mark that the thread can be executed by CPU, but the specific execution time is determined by CPU.

2.1 System.Threading.Thread Class

The Thread class is the basic class that controls threads, is located under the System.Threading namespace, and has four overloaded constructors:

The name indicates that Thread (ParameterizedThreadStart) initializes a new instance of the Thread class, specifying a delegate that allows the object to be passed to the thread when it starts. The method to be executed has a parameter. Thread (ParameterizedThreadStart,   Int32) initializes a new instance of the Thread class, specifies a delegate that allows the object to pass to the thread when it starts, and specifies the thread's maximum stack size Thread (ThreadStart) to initialize a new instance of the Thread class. The method to be executed is nonparametric. Thread (ThreadStart,   Int32) initializes a new instance of the Thread class, specifying the maximum stack size of the thread.

ThreadStart is a delegate with no parameters and a return value of void. Delegate is defined as follows:

Public delegate void ThreadStart ()

Create and run a thread through the ThreadStart delegate:

Class Program {static void Main (string [] args) {/ / create a thread without parameters Thread thread1 = new Thread (new ThreadStart (Thread1)); / / call the Start method to execute the thread thread1.Start (); Console.ReadKey () } / create a method without parameters / static void Thread1 () {Console.WriteLine ("this is a method without parameters");}}

Running result

In addition to running static methods, you can also run instance methods

Class Program {static void Main (string [] args) {/ / create an instance of the ThreadTest class ThreadTest test=new ThreadTest (); / / call the MyThread method of the test instance Thread thread = new Thread (new ThreadStart (test.MyThread)); / / start the thread thread.Start (); Console.ReadKey () }} class ThreadTest {public void MyThread () {Console.WriteLine ("this is an instance method");}}

Running result:

For simplicity, you can also assign a value to the constructor of Thread through anonymous delegates or Lambda expressions

Static void Main (string [] args) {/ / create Thread thread1 = new Thread by anonymous delegate (delegate () {Console.WriteLine ("I am a thread created by anonymous delegate"); thread1.Start (); / / create Thread thread2 = new Thread (() = > Console.WriteLine ("I am a delegate created by Lambda expression") through Lambda expression; thread2.Start () Console.ReadKey ();}

Running result:

ParameterizedThreadStart is a delegate with parameters and the return value is void. It is defined as follows:

Public delegate void ParameterizedThreadStart (Object obj)

Class Program {static void Main (string [] args) {/ / create thread Thread thread = new Thread (new ParameterizedThreadStart (Thread1)) through ParameterizedThreadStart; / / pass the value thread.Start to the method ("this is a delegate with parameters"); Console.ReadKey () } / create a method with parameters / Note: the parameter type in the method must be Object type / static void Thread1 (object obj) {Console.WriteLine (obj);}}

Note: the parameter type of the ParameterizedThreadStart delegate must be Object. If you are using a delegate without parameters, you cannot use the Start method with parameters to run the thread, otherwise the system will throw an exception. But with a delegate with parameters, you can use thread.Start () to run the thread, where the parameter value passed is null.

2.2 the common attribute name of the thread indicates the current context in which the thread is being executed by the CurrentContext. CurrentThread gets the currently running thread. ExecutionContext gets an ExecutionContext object that contains information about the various contexts of the current thread. IsAlive gets a value indicating the execution status of the current thread. IsBackground gets or sets a value indicating whether a thread is a background thread. IsThreadPoolThread gets a value indicating whether the thread belongs to the managed thread pool. ManagedThreadId gets the unique identifier of the current managed thread. Name gets or sets the name of the thread. Priority gets or sets a value indicating the scheduling priority of the thread. ThreadState gets a value that contains the state of the current thread. 2.2.1 Identifier of the thread

ManagedThreadId is the unique identifier of the acknowledgement thread, and the program identifies the thread through Thread.ManagedThreadId in most cases. And Name is a variable value, by default, Name is a null value Null, developers can set the name of the thread through the program, but this is only an auxiliary feature.

2.2.2 priority of threads

When threads compete for CPU time, CPU gives service according to the thread's priority. High-priority threads can completely prevent low-priority threads from executing. Net sets the Priority property for threads to define the priority of thread execution, which contains five options, of which Normal is the default. Unless the system has special requirements, you should not casually set the priority of threads.

The member name indicates that Lowest can schedule Thread after a thread with any other priority. BelowNormal can schedule Thread after a thread with Normal priority and before a thread with Lowest priority. Normal is selected by default. You can schedule Thread after a thread with AboveNormal priority and before a thread with BelowNormal priority. AboveNormal can schedule Thread after a thread with Highest priority and before a thread with Normal priority. Highest can schedule Thread before a thread with any other priority. 2.2.3 status of threads

Through ThreadState, you can detect that the thread is in the state of Unstarted, Sleeping, Running, and so on, which provides more specific information than IsAlive performance.

As mentioned earlier, multiple contexts may be included in an application domain, and the current context of the thread can be obtained through CurrentContext.

CurrentThread is the most commonly used attribute, which is used to get the currently running thread.

2.2.4 method of System.Threading.Thread

Thread includes several methods to control thread creation, suspension, stop, and destruction, which will be used frequently in future examples.

The method name indicates that Abort () terminates the thread. GetDomain () returns the current domain in which the current thread is running. GetDomainId () returns the current domain Id in which the current thread is running. Interrupt () interrupts a thread in the state of a WaitSleepJoin thread. Join () has been overloaded. Blocks the calling thread until a thread terminates. Resume () continues to run the suspended thread. Start () executes this thread. Suspend () suspends the current thread, which does not work if the current thread is already in a suspended state. Sleep () suspends the running thread for a period of time.

Thread example

Static void Main (string [] args) {/ / get the running thread Thread thread = Thread.CurrentThread; / / set the name of the thread thread.Name = "main thread"; / / get the unique identifier of the current thread int id = thread.ManagedThreadId / / get the status of the current thread ThreadState state= thread.ThreadState; / / get the priority ThreadPriority priority= thread.Priority of the current thread String strMsg = string.Format ("Thread ID: {0}\ n" + "Thread Name: {1}\ n" + "Thread State: {2}\ n" + "Thread Priority: {3}\ n", id, thread.Name, state, priority); Console.WriteLine (strMsg); Console.ReadKey ();}

Running result:

2.3 foreground and background threads

Foreground thread: the application can end only if all foreground threads are finished. By default, all threads created are foreground threads.

Background thread: as long as all the foreground threads end, the background thread ends automatically. Set up background threads through Thread.IsBackground. The type of the thread must be set before calling the Start method, otherwise once the thread runs, it cannot be changed.

Threads that run through the BeginXXX method are background threads.

Class Program {static void Main (string [] args) {/ / demonstrate foreground and background threads BackGroundTest background = new BackGroundTest (10); / / create foreground threads Thread fThread = new Thread (new ThreadStart (background.RunLoop)); / / name threads fThread.Name = "foreground threads" BackGroundTest background1 = new BackGroundTest (20); / / create background thread Thread bThread = new Thread (new ThreadStart (background1.RunLoop)); bThread.Name = "background thread"; / / set to background thread bThread.IsBackground = true; / / start thread fThread.Start (); bThread.Start () }} class BackGroundTest {private int Count; public BackGroundTest (int count) {this.Count = count;} public void RunLoop () {/ / get the name of the current thread string threadName = Thread.CurrentThread.Name; for (int I = 0; I

< Count; i++) { Console.WriteLine("{0}计数：{1}",threadName,i.ToString()); //线程休眠500毫秒 Thread.Sleep(1000); } Console.WriteLine("{0}完成计数",threadName); } } 运行结果：前台线程执行完，后台线程未执行完，程序自动结束。 把bThread.IsBackground = true注释掉，运行结果：主线程执行完毕后(Main函数)，程序并未结束，而是要等所有的前台线程结束以后才会结束。 后台线程一般用于处理不重要的事情，应用程序结束时，后台线程是否执行完成对整个应用程序没有影响。如果要执行的事情很重要，需要将线程设置为前台线程。 2.4 线程同步 所谓同步：是指在某一时刻只有一个线程可以访问变量。 如果不能确保对变量的访问是同步的，就会产生错误。 c#为同步访问变量提供了一个非常简单的方式，即使用c#语言的关键字Lock，它可以把一段代码定义为互斥段，互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。在c#中，关键字Lock定义如下： Lock(expression){statement_block} expression代表你希望跟踪的对象： 如果你想保护一个类的实例，一般地，你可以使用this； 如果你想保护一个静态变量（如互斥代码段在一个静态方法内部），一般使用类名就可以了 而statement_block就算互斥段的代码，这段代码在一个时刻内只可能被一个线程执行。 以书店卖书为例 class Program { static void Main(string[] args) { BookShop book = new BookShop(); //创建两个线程同时访问Sale方法 Thread t1 = new Thread(new ThreadStart(book.Sale)); Thread t2 = new Thread(new ThreadStart(book.Sale)); //启动线程 t1.Start(); t2.Start(); Console.ReadKey(); } } class BookShop { //剩余图书数量 public int num = 1; public void Sale() { int tmp = num; if (tmp >

0) / / judge whether there is a book, if so, you can sell {Thread.Sleep (1000); num-= 1; Console.WriteLine ("one book has been sold, there are {0} copies left", num);} else {Console.WriteLine ("gone") }}}

Running result:

From the running results, we can see that the two threads access the shared resources synchronously, without considering the problem of synchronization, and the result is incorrect.

Considering thread synchronization, the improved code:

Class Program {static void Main (string [] args) {BookShop book = new BookShop (); / / create two threads to access the Sale method Thread T1 = new Thread (new ThreadStart (book.Sale)); Thread T2 = new Thread (new ThreadStart (book.Sale)); / / start thread t1.Start () T2.Start (); Console.ReadKey ();}} class BookShop {/ / number of remaining books public int num = 1; public void Sale () {/ / use lock keyword to solve thread synchronization problem lock (this) {int tmp = num If (tmp > 0) / / judge whether there is a book, if so, you can sell {Thread.Sleep (1000); num-= 1; Console.WriteLine ("one book is sold, there are {0} copies left", num) } else {Console.WriteLine ("gone");}}

Running result:

2.5 Cross-thread access

Click "Test" to create a thread that loops from 0 to 10000 to assign values to the text box, as follows:

Private void btn_Test_Click (object sender, EventArgs e) {/ / create a thread to execute this method: the default thread created is the foreground thread Thread thread = new Thread (new ThreadStart (Test)) / / the Start method marks that the thread is ready and can be executed at any time. It is up to CPU to decide / / set the thread to the background thread thread.IsBackground = true; thread.Start ();} private void Test () {for (int I = 0; I)

< 10000; i++) { this.textBox1.Text = i.ToString(); } } 运行结果： 产生错误的原因：textBox1是由主线程创建的，thread线程是另外创建的一个线程，在.NET上执行的是托管代码，C#强制要求这些代码必须是线程安全的，即不允许跨线程访问Windows窗体的控件。 解决方案： 1、在窗体的加载事件中，将C#内置控件(Control)类的CheckForIllegalCrossThreadCalls属性设置为false，屏蔽掉C#编译器对跨线程调用的检查。 private void Form1_Load(object sender, EventArgs e) { //取消跨线程的访问 Control.CheckForIllegalCrossThreadCalls = false; } 使用上述的方法虽然可以保证程序正常运行并实现应用的功能，但是在实际的软件开发中，做如此设置是不安全的（不符合.NET的安全规范），在产品软件的开发中，此类情况是不允许的。如果要在遵守.NET安全标准的前提下，实现从一个线程成功地访问另一个线程创建的空间，要使用C#的方法回调机制。 2、使用回调函数 回调实现的一般过程： C#的方法回调机制，也是建立在委托基础上的，下面给出它的典型实现过程。 （1）、定义、声明回调。 //定义回调private delegate void DoSomeCallBack(Type para);//声明回调DoSomeCallBack doSomaCallBack; 可以看出，这里定义声明的"回调"（doSomaCallBack）其实就是一个委托。 （2）、初始化回调方法。 doSomeCallBack=new DoSomeCallBack(DoSomeMethod); 所谓"初始化回调方法"实际上就是实例化刚刚定义了的委托，这里作为参数的DoSomeMethod称为"回调方法"，它封装了对另一个线程中目标对象（窗体控件或其他类）的操作代码。 （3）、触发对象动作 Opt obj.Invoke(doSomeCallBack,arg); 其中Opt obj为目标操作对象，在此假设它是某控件，故调用其Invoke方法。Invoke方法签名为： object Control.Invoke(Delegate method,params object[] args); 它的第一个参数为委托类型，可见"触发对象动作"的本质，就是把委托doSomeCallBack作为参数传递给控件的Invoke方法，这与委托的使用方式是一模一样的。 最终作用于对象Opt obj的代码是置于回调方法体DoSomeMethod()中的，如下所示： private void DoSomeMethod(type para){//方法体Opt obj.someMethod(para);} 如果不用回调，而是直接在程序中使用"Opt obj.someMethod(para);"，则当对象Opt obj不在本线程（跨线程访问）时就会发生上面所示的错误。 从以上回调实现的一般过程可知：C#的回调机制，实质上是委托的一种应用。在C#网络编程中，回调的应用是非常普遍的，有了方法回调，就可以在.NET上写出线程安全的代码了。 使用方法回调，实现给文本框赋值： namespace MultiThreadDemo{ public partial class Form1 : Form { public Form1() { InitializeComponent(); } //定义回调 private delegate void setTextValueCallBack(int value); //声明回调 private setTextValueCallBack setCallBack; private void btn_Test_Click(object sender, EventArgs e) { //实例化回调 setCallBack = new setTextValueCallBack(SetValue); //创建一个线程去执行这个方法:创建的线程默认是前台线程 Thread thread = new Thread(new ThreadStart(Test)); //Start方法标记这个线程就绪了，可以随时被执行，具体什么时候执行这个线程，由CPU决定 //将线程设置为后台线程 thread.IsBackground = true; thread.Start(); } private void Test() { for (int i = 0; i < 10000; i++) { //使用回调 textBox1.Invoke(setCallBack, i); } } /// /// 定义回调使用的方法 /// /// private void SetValue(int value) { this.textBox1.Text = value.ToString(); } }}2.6 终止线程 若想终止正在运行的线程，可以使用Abort（）方法。 三、同步和异步 同步和异步是对方法执行顺序的描述。 同步：等待上一行完成计算之后，才会进入下一行。 例如：请同事吃饭，同事说很忙，然后就等着同事忙完，然后一起去吃饭。 异步：不会等待方法的完成，会直接进入下一行，是非阻塞的。 例如：请同事吃饭，同事说很忙，那同事先忙，自己去吃饭，同事忙完了他自己去吃饭。 下面通过一个例子讲解同步和异步的区别 1、新建一个winform程序，上面有两个按钮，一个同步方法、一个异步方法，在属性里面把输出类型改成控制台应用程序，这样可以看到输出结果，代码如下： using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading;using System.Threading.Tasks;using System.Windows.Forms;namespace MyAsyncThreadDemo{ public partial class Form1 : Form { public Form1() { InitializeComponent(); } /// /// 异步方法 /// /// /// private void btnAsync_Click(object sender, EventArgs e) { Console.WriteLine($"***************btnAsync_Click Start {Thread.CurrentThread.ManagedThreadId}"); Action action = this.DoSomethingLong; // 调用委托(同步调用) action.Invoke("btnAsync_Click_1"); // 异步调用委托 action.BeginInvoke("btnAsync_Click_2",null,null); Console.WriteLine($"***************btnAsync_Click End {Thread.CurrentThread.ManagedThreadId}"); } /// /// 同步方法 /// /// /// 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 j = 3; int k = 5; int m = j + k; for (int i = 0; i < 5; i++) { string name = string.Format($"btnSync_Click_{i}"); this.DoSomethingLong(name); } } 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; } Console.WriteLine($"****************DoSomethingLong {name} End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}***************"); } }} 2、启动程序，点击同步，结果如下： 从上面的截图中能够很清晰的看出：同步方法是等待上一行代码执行完毕之后才会执行下一行代码。 点击异步，结果如下： 从上面的截图中看出：当执行到action.BeginInvoke("btnAsync_Click_2",null,null);这句代码的时候，程序并没有等待这段代码执行完就执行了下面的End，没有阻塞程序的执行。 在刚才的测试中，如果点击同步，这时winform界面不能拖到，界面卡住了，是因为主线程(即UI线程)在忙于计算。 点击异步的时候，界面不会卡住，这是因为主线程已经结束，计算任务交给子线程去做。 在仔细检查上面两个截图，可以看出异步的执行速度比同步执行速度要快。同步方法执行完将近16秒，异步方法执行完将近6秒。 在看下面的一个例子，修改异步的方法，也和同步方法一样执行循环，修改后的代码如下： private void btnAsync_Click(object sender, EventArgs e){ Console.WriteLine($"***************btnAsync_Click Start {Thread.CurrentThread.ManagedThreadId}"); //Action action = this.DoSomethingLong; //// 调用委托(同步调用) //action.Invoke("btnAsync_Click_1"); //// 异步调用委托 //action.BeginInvoke("btnAsync_Click_2",null,null); Action action = this.DoSomethingLong; for (int i = 0; i < 5; i++) { //Thread.Sleep(5); string name = string.Format($"btnAsync_Click_{i}"); action.BeginInvoke(name, null, null); } Console.WriteLine($"***************btnAsync_Click End {Thread.CurrentThread.ManagedThreadId}");} 结果如下： 从截图中能够看出：同步方法执行是有序的，异步方法执行是无序的。异步方法无序包括启动无序和结束无序。启动无序是因为同一时刻向操作系统申请线程，操作系统收到申请以后，返回执行的顺序是无序的，所以启动是无序的。结束无序是因为虽然线程执行的是同样的操作，但是每个线程的耗时是不同的，所以结束的时候不一定是先启动的线程就先结束。从上面同步方法中可以清晰的看出：btnSync_Click_0执行时间耗时不到3秒，而btnSync_Click_1执行时间耗时超过了3秒。可以想象体育比赛中的跑步，每位运动员听到发令枪起跑的顺序不同，每位运动员花费的时间不同，最终到达终点的顺序也不同。 总结一下同步方法和异步方法的区别： 1、同步方法由于主线程忙于计算，所以会卡住界面。 异步方法由于主线程执行完了，其他计算任务交给子线程去执行，所以不会卡住界面，用户体验性好。 2、同步方法由于只有一个线程在计算，所以执行速度慢。 异步方法由多个线程并发运算，所以执行速度快，但并不是线性增长的（资源可能不够）。多线程也不是越多越好，只有多个独立的任务同时运行，才能加快速度。 3、同步方法是有序的。 异步多线程是无序的：启动无序，执行时间不确定，所以结束也是无序的。一定不要通过等待几毫秒的形式来控制线程启动/执行时间/结束。 四、回调 先来看看异步多线程无序的例子： 在界面上新增一个按钮，实现代码如下： 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")}***************"); Action action = this.DoSomethingLong; action.BeginInvoke("btnAsyncAdvanced_Click", null, null); // 需求：异步多线程执行完之后再打印出下面这句 Console.WriteLine($"到这里计算已经完成了。{Thread.CurrentThread.ManagedThreadId.ToString("00")}。"); Console.WriteLine($"****************btnAsyncAdvanced_Click End {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");} 运行结果： 从上面的截图中看出，最终的效果并不是我们想要的效果，而且打印输出的还是主线程。 既然异步多线程是无序的，那我们有没有什么办法可以解决无序的问题呢？办法当然是有的，那就是使用回调，.NET框架已经帮我们实现了回调： BeginInvoke的第二个参数就是一个回调，那么AsyncCallback究竟是什么呢？F12查看AsyncCallback的定义： 发现AsyncCallback就是一个委托，参数类型是IAsyncResult，明白了AsyncCallback是什么以后，将上面的代码进行如下的改造： 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")}***************"); Action action = this.DoSomethingLong; // 定义一个回调 AsyncCallback callback = p =>

{Console.WriteLine ($"calculation has been completed here. {Thread.CurrentThread.ManagedThreadId.ToString (" 00 ")}.) ;}; / / callback as parameter action.BeginInvoke ("btnAsyncAdvanced_Click", callback, null); Console.WriteLine ($"* btnAsyncAdvanced_Click End {Thread.CurrentThread.ManagedThreadId.ToString (" 00 ")} {DateTime.Now.ToString (" yyyy-MM-dd HH:mm:ss.fff ")} *");}

Running result:

As you can see in the screenshot above, this is the effect we want, and the print is output by a child thread, but how on earth does the program achieve it? We can make the following conjecture:

When the program executes to BeginInvoke, it will apply for a thread based on thread pool. The thread will complete the execution of the delegate (in this case, execute the DoSomethingLong () method). After the delegate is executed, the thread will execute the delegate of callback callback. Executing the callback delegate requires a parameter of type IAsyncResult. How does this parameter of type IAsyncResult come from? Right mouse button over BeginInvoke to view the returned value:

It is found that the return value of BeginInvoke is of type IAsyncResult. So is this return value the parameter of the callback delegate? Make the following changes to the code:

Private void btnAsyncAdvanced_Click (object sender, EventArgs e) {/ / requirements: print the following Console.WriteLine ($"* btnAsyncAdvanced_Click Start {Thread.CurrentThread.ManagedThreadId.ToString (" 00 ")} {DateTime.Now.ToString (" yyyy-MM-dd HH:mm:ss.fff ")} *") after asynchronous multithreading execution. Action action = this.DoSomethingLong; / / unordered / / action.BeginInvoke ("btnAsyncAdvanced_Click", null, null); IAsyncResult asyncResult = null / / define a callback AsyncCallback callback = p = > {/ / compare whether the two variables are the same Console.WriteLine (object.ReferenceEquals (pforce asyncResult)); Console.WriteLine ($"the calculation has been completed here. {Thread.CurrentThread.ManagedThreadId.ToString ("00")}. ") ;}; / / callback as parameter asyncResult= action.BeginInvoke ("btnAsyncAdvanced_Click", callback, null) Console.WriteLine ($"* btnAsyncAdvanced_Click End {Thread.CurrentThread.ManagedThreadId.ToString (" 00 ")} {DateTime.Now.ToString (" yyyy-MM-dd HH:mm:ss.fff ")} *");}

Results:

Here you can see that the return value of BeginInvoke is the parameter of the callback delegate.

Now we can use callbacks to solve the problem of asynchronous multithreading disorder.

2. Get the return value of the delegate asynchronous call

You can use EndInvoke to get the return value of a delegate asynchronous call, as shown in the following example:

Private void btnAsyncReturnVlaue_Click (object sender, EventArgs e) {/ / defines a delegate with no parameters and a return value of int type Func func = () = > {Thread.Sleep (2000); return DateTime.Now.Day;}; / / outputs the return value of the delegate synchronous call Console.WriteLine ($"func.Invoke () = {func.Invoke ()}") / / IAsyncResult asyncResult of delegate asynchronous call = func.BeginInvoke (p = > {Console.WriteLine (p.AsyncState);}, "return value of asynchronous call"); / / output the return value of delegate asynchronous call Console.WriteLine ($"func.EndInvoke (asyncResult) = {func.EndInvoke (asyncResult)}");}

Results:

The above is all the content of this article "how to use C# multithreading". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

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.