c＃中的异步任务

Question

I have two tasks Job1 and Job2 and below is the code. First time I ran Job1 and Job2 in a sequence and got the stopwatch output as 844 milliseconds. Second time I commented sequential jobs and called parallel task processing and got the stopwatch result as 11352 milliseconds. My assumption/expectation was I should get the output as 422 (because 844/2) or somewhere near to it. But the result is totally opposite. I need to wait both the jobs to be completed and hence I put t1.Wait() and t2.Wait(); Please help me to process these two jobs in half of sequential processing. Please find my code below:

    public ActionResult Index()
    {
        Stopwatch s = new Stopwatch();
        s.Start();

        //Execute 2 jobs in a sequence
        Job1();
        Job2();

        //Execute 2 jobs in parallel
        //var t1 = Task.Run(() => { Job1(); });
        //var t2 = Task.Run(() => { Job2(); });
        //t1.Wait();
        //t2.Wait();

        s.Stop();
        Debug.WriteLine("ElapsedMilliseconds: " + s.ElapsedMilliseconds);
        return View();
    }

    private void Job1()
    {
        for (int i = 0; i < 1000; i++)
        {
            Debug.WriteLine(i);
        }
    }

    private void Job2()
    {
        for (int i = 2000; i < 3000; i++)
        {
            Debug.WriteLine(i);
        }
    }

Answer 1

Essentially your 2nd example is slower due to the overhead of Debug.WriteLine during concurrency.

You'd notice a big difference if you remove Debug.WriteLine (which calls OutputDebugString under the hood).

MSDN states:

Applications should send very minimal debug output and provide a way for the user to enable or disable its use. To provide more detailed tracing, see Event Tracing.

As Eran states here:

" if several threads call OutputDebugString concurrently, they will be synchronized " .

There's no concurrency in your first example so that could be a reason why its faster.

Also you might want to consider moving to a single wait.

Change your code from this:

//Execute 2 jobs in parallel
var t1 = Task.Run(() => { Job1(); });
var t2 = Task.Run(() => { Job2(); });
t1.Wait();
t2.Wait();

...to this:

//Execute 2 jobs in parallel
var tasks = new List<Task>();
tasks.Add(Task.Run(() => { Job1(); }));
tasks.Add(Task.Run(() => { Job2(); }));
Task.WaitAll(tasks.ToArray());

Answer 2

To understand why Tasks have nothing to do with performance but more with responsiveness you should read up on

Context switching: https://en.wikipedia.org/wiki/Context_switch

The processor uses lots of cycles to switch to another thread

Mutexes : https://en.wikipedia.org/wiki/Mutual_exclusion

Every time you call Debug.WriteLine the Task waits until Debug.WriteLine in the other Task is done and performs a context switch.