CODEWITHSUNDEEP
c#multithreadingfor-looplockingsemaphore
learntogrow-growtolearn
learntogrow-growtolearn

Reputation: 1280

MultiThreading - For loop doesnt waits on Await

I have a console application with have two threads as:

    public static async void Thread1()
        {
            for (int i = 0; i < 100; i++)
            {
                Debug.WriteLine("Thread1 " + i);
                await MyFunc();
            }
        }

    public static async void Thread2()
        {
            for (int i = 0; i < 100; i++)
            {
                Debug.WriteLine("Thread2 " + i);
                await MyFunc();
            }
        }
    public static void Main(string[] args)
        {
            MainAsync(args).GetAwaiter().GetResult();
        }
    private static async Task MainAsync(string[] args)
        {

            Console.WriteLine("Before start thread");

            Thread tid1 = new Thread(Thread1);
            Thread tid2 = new Thread(Thread2);

            tid1.Start();

            tid2.Start();
        }

    public static async Task MyFunc()
        {
         //do something
        }

However, when the application run and terminates, it seems that only each thread is run just once as I see only below things in output:

 Before start thread
    Thread1 0
    Thread2 0
//some thing from MyFunc

I expect or rather wannt to run each thread till the for loop.It seems to me that the for loop continues to run despite the await. If yes, what could be other probable approach.

Any leads would be helpful.

Upvotes: 0

Views: 91

Answers (3)

John Wu
John Wu

Reputation: 52210

You aren't doing anything to wait for the threads. The main routine will just continue on until it returns to the O/S, which will kill the process and any child threads. Since you aren't doing anything else, this happens almost immediately, cutting both threads' lives short.

If you want to wait for the threads to finish, you can refer to this answer and write some variation of

while (thread1.IsAlive || thread2.IsAlive)
{
    //Do something to wait
}

...before exiting.

That being said, you should probably using Tasks instead of threads, e.g.

public static async Task Task1()
{
    for (int i = 0; i < 100; i++)
    {
        Debug.WriteLine("Task1 " + i);
        await MyFunc();
    }
}

public static async Task Task2()
{
    for (int i = 0; i < 100; i++)
    {
        Debug.WriteLine("Task2 " + i);
        await MyFunc();
    }
}

And then to execute and wait for both of them:

Task.WaitAll
( 
    new[] 
    {
        Task1(), 
        Task2() 
    } 
);

See this code in action on DotNetFiddle

See also What is the difference between tasks and threads?

Upvotes: 2

Shane Ray
Shane Ray

Reputation: 1459

Use async Task instead of async void

private static async Task MainAsync(string[] args)
{
    Console.WriteLine("Before start thread");
    var task1 = Thread1();
    var task2 = Thread2();
    var taskList = new [] { task1, task2 };
    Task.WaitAll(taskList);
}

Upvotes: 1

spender
spender

Reputation: 120380

You seem to have a lot of confusion about the role of threads and tasks, so it's a good idea to read up about it. Steven Cleary has a nice write-up about this. "There Is No Thread"

From the comments, it seems that your actual intention here is to run two async tasks in parallel, then to wait until they are both finished.

If you want to wait for two async tasks to complete in parallel, make sure your async methods actually return Task then:

Task task1 = DoSomethingAsync(); //don't await
Task task2 = DoSomethingElseAsync(); //don't await

then you can wait asynchronously for Task.WhenAll:

await Task.WhenAll(task1,task2);

You really don't need to be involving Thread at all.

Upvotes: 2

Related Questions