Here I would like to emphasize a concept,
Multithreading is multi-threading,
Asynchronous programming is asynchronous programming
These two are the concepts of distinction;
I can say that multithreading is inherently asynchronous, but you can't say that multithreading is equivalent to our asynchronous programming;
The root cannot say that asynchronous programming is our multithreading. Don't confuse it here;
The evolution in re-NET is as follows:
Multithreading: Thread =>threadpool=> Task
Asynchronous Programming: Bengininvokexxx endinvokexxx iasyncresult=> Async await (this is used in conjunction with Task).
OK next, to summarize the wait for our thread (Task).
Summarize:
Method One: Thread.Sleep (), this to estimate that the waiting time should be greater than the time our child thread executes.
Method Two: Of course is our most commonly used join () method, blocking the current method of calling the Chengcheng, until our sub-thread execution is complete.
Method Two: Main thread rotation sub-thread (this is based on our IAsyncResult programming mode, in time the legendary beginxxxx endxxxx this mode)
Method Three: The method of using the notification is our EEVNTWAITHANLD = new Autoresteevnt (false), and then WaitOne and Set the way to proceed, the effect is very good drop ah;
Method Four: I named it as a folk prescription: is the use of exclusive locking mechanism, when the child thread after the lock, release, to our main thread, the premise is to ensure that our child thread first get lock;
Method Five: This is the wait method based on our task;
Here I give some, practice demo, only for reference use;
usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;namespaceconsoleapplication13{//we call it waiting for a child thread, or waiting for a child thread for a certain amount of time;//The most primitive is the method of using waiteevnt; we can even use the poll way;//and the callback mode based on event programming; Public classPerson {}classProgram {//evnet wait handle//This method can also be used for thread synchronization. Public Static ObjectLocker =New Object(); Public StaticEventWaitHandle handler =NewAutoResetEvent (false); Public Static voidEat () {Thread.Sleep ( the); } Public Static voidEat_withset () {Thread.Sleep ( the); Handler. Set (); //a sub-thread sends a signal to be done; } Public Static voidEat_withlock () {Console.WriteLine ("Shackles begin"); Lock(Locker) {Thread.Sleep ( the);//Suppose we have a lot of things to do here;//The effect is very good;} Console.WriteLine ("Shackle Release"); } Public Static voidEat_loop () { for(inti =0; I <Ten; i++) {Thread.Sleep ( +); Console.WriteLine ("Child"); } } //then this method can't be empty. Public Static voideat_wait () { for(inti =0; I <Ten; i++) {Task.delay ( +). Wait (); Console.WriteLine ("Child"); } } Public Static voidTestjoin () {Console.WriteLine ("Main start"); Thread Thread=NewThread (Eat); Thread. Start (); //wait for me.Console.WriteLine ("The main thread does something else first;"); //This we can directly use the thread to bring the method;thread. Join (); Console.WriteLine ("OK, the sub-threading is done ."); Console.WriteLine ("Main End"); Console.ReadLine (); } Public Static voidTest_set () {Console.WriteLine ("Main start"); Thread Thread=NewThread (Eat_withset); Thread. Start (); //wait for me.Console.WriteLine ("The main thread does something else first;"); Handler. WaitOne (); Console.WriteLine ("OK, the sub-threading is done ."); Console.WriteLine ("Main End"); Console.ReadLine (); } Public Static voidTest11 () {Console.WriteLine ("Main start"); Thread Thread=NewThread (Eat_withset); Thread. Start (); //wait for me.Console.WriteLine ("The main thread does something else first;"); Handler. WaitOne (Timespan.fromseconds (3)); //note here, a little waitone and task.wait if both specify the waiting time;//If the child thread does not finish the time within the specified time, then we begin the method of the main thread;//There is no real cancellation thread here;//The problem comes again, if you want to cancel the sub-thread;Console.WriteLine ("Okay, no clogging, the main thread is gone,"); Console.WriteLine ("Main End"); Console.ReadLine (); } //Folk prescription Public Static voidTest_lock () {Console.WriteLine ("Main start"); Thread Thread=NewThread (Eat_withlock); Thread. Start (); //wait for me.Console.WriteLine ("The main thread does something else first;"); //if it is single-layer, I still use a little folk prescription;//that is our lock method drops ah;Thread.Sleep ( -);//in order for the child thread to get the lock, we're estimating sleep here.//so it is called folk prescription; Lock(locker) {//Of course this way, is completely out of a four-level state;//wait for another thread to release the lock;Console.WriteLine ("This means that one of our other threads has finished executing;"); } console.readline (); } //If you want to cancel the original method, but also get the original method to operate, the whole is a troublesome thing;//But there is more convenience in our task; Public Static voidTest_task () {//The cancellation of task is relatively simple;Console.WriteLine ("Main start"); Task Task= Task.run (() =eat_wait ()); Console.WriteLine ("Mian do something.then wait task"); //task. Wait (); //By default, it waits for the task to finish executing;task. Wait (Timespan.fromseconds (3));//here can only wait three seconds, three seconds only, do not block our main thread;//Here's the thing to note is that waiting does not equal cancellation oh;//this point is relatively critical;//Let's start with a little bit of thread cancellation .Console.WriteLine ("Task completed ..."); Console.WriteLine ("Main End"); Console.ReadLine (); } Static voidMain (string[] args) { //Test (); //Test1 (); //Test11 (); //Test_lock (); //Test_task (); } }}
Here I am going to show you a set, to notify instances of multiple threads, or to understand that a broadcast is the same as passing messages;
Or: Multiple threads are waiting for a signal from a thread;
C # thread waits (blocked)