为什么任务没有执行？

Question

I have below code:

class Program
{
    static void Main(string[] args)
    {

        Task[] tasks = new Task[3]
                        {
                            Task.Factory.StartNew(() => Console.WriteLine("Hello A")),
                            Task.Factory.StartNew(() => Console.WriteLine("Hello B")),
                            Task.Factory.StartNew(() => Console.WriteLine("Hello C"))
                        };
        Task.WaitAll(tasks); 
        Console.WriteLine("Hi ABC");
    }
}

I build and run the above code, it gives output:
Hello C
Hello B
Hello A
Hi ABC

But if I comment Task.WaitAll(tasks), one of the outputs is:
Hi ABC
Hello B
Hello C

Does it mean when Console.WriteLine("Hi ABC") finishes execution, thread which executes Console.WriteLine("Hello A") didn't get a chance to finish execution?

Answer 1

Yes, that's correct. Your main thread is terminating the process before the child threads have finished - or started in some cases. If you don't do something to keep the main thread busy, then when the main thread terminates (after "Hi ABC"), the process termination will kill all outstanding threads. If the A thread (or any of the child threads) hasn't been scheduled yet, then it won't have a chance to output at all.

Answer 2

If you don't wait for the tasks, all four of your threads (three tasks plus the main thread) run at the same time.

Since the main thread doesn't need to start up, it's likely to get to the print statement first.

Answer 3

It means that the Thread ends or that it got killed after the Program has finished. You should add Console.ReadLine(); to wait manually and you will see that they all end.

Answer 4

Without the WaitAll , the execution continues normally. After your last Console.WriteLine , the application terminates because it's reached the end of the program.

Answer 5

What you have here is what is known as a "race condition". In other words, the order of the Hello A , Hello B , Hello C , and Hi ABC is arbitrary, and could change depending on which thread finishes first. So different runs could yield different results.

What's happening is that you are spinning off these threads, then continuing execution of the program. In this case, your race condition is which threads can print their output before being killed off as the main execution thread dies (the end of the program). The output from the main thread is not guaranteed to be first, but because it has less overhead from being started, it's likely to be first. You can test this by changing the Task.WaitAll to a System.Threading.Thread.Sleep(200) and see what your output becomes as you modify the milliseconds you pass into the Sleep method.

Without waiting, the main thread kills off child threads regardless of what condition they are in. In the case you mentioned, threads B and C had completed between the Console.WriteLine('Hi ABC') and the end of the program. Thread A did not finish, so it got killed before it could output.