How can I run both of these methods 'at the same time' in .NET 4.5?
Solution 1
Here is what you may want to do:
public async Task<PewPew> SomeMethod(Foo foo)
{
// get the stuff on another thread
var cTask = Task.Run(() => GetAllTheCats(foo));
var fTask = Task.Run(() => GetAllTheFood(foo));
var cats = await cTask;
var food = await fTask;
return new PewPew
{
Cats = cats,
Food = food
};
}
public IList<Cat> GetAllTheCats(Foo foo)
{
// Do stuff, like hit the Db, spin around, dance, jump, etc...
// It all takes some time.
return cats;
}
public IList<Food> GetAllTheFood(Foo foo)
{
// Do more stuff, like hit the Db, nom nom noms...
// It all takes some time.
return food;
}
There are two things you need to understand here:
1) What is diff between this:
var cats = await cTask;
var food = await fTask;
And this:
Task.WaitAll(new [] {cTask, fTask});
Both will give you similar result in the sense let the 2 async
tasks finish and then return new PewPew
- however, difference is that Task.WaitAll()
will block the current thread (if that is UI thread, then UI will freeze). instead, await
will break down the SomeMethod
say in a state machine, and return from the SomeMethod
to its caller as it encounters await
keyword. It will not block the thread. The Code below await
will be scheduled to run when async
task is over.
2) You could also do this:
var cats = await Task.Run(() => GetAllTheCats(foo));
var food = await Task.Run(() => GetAllTheFood(foo));
However, this will not start the async
tasks simultaneously. Second task will start after the first is over. This is because how the await
keyword works, hope that helps...
EDIT: How to use SomeMethod
- somewhere at the start of the call tree, you have to use Wait()
or Result
property - OR - you have to await
from async void
.
Generally, async void
would be an event handler:
public async void OnSomeEvent(object sender, EventArgs ez)
{
Foo f = GetFoo();
PewPew p = await SomeMethod(f);
}
If not then use Result
property.
public Foo2 NonAsyncNonVoidMethod()
{
Foo f = GetFoo();
PewPew p = SomeMethod(f).Result; //But be aware that Result will block thread
return GetFoo2(p);
}
Solution 2
By far the easiest way to do this is to use Parallel.Invoke()
IList<Cat> cats;
IList<Food> food;
Parallel.Invoke
(
() => cats = GetAllTheCats(foo),
() => food = GetAllTheFood(foo)
);
Parallel.Invoke()
will wait for all the methods to return before it itself returns.
More information here: http://msdn.microsoft.com/en-us/library/dd460705.aspx
Note that Parallel.Invoke()
handles scaling to the number of processors in your system, but that only really matters if you're starting more than just a couple of tasks.
Solution 3
You don't have to use async if you're not in an async method or you're using an older version of the .Net framework.. just use Tasks for simplicity:
Task taskA = Task.Factory.StartNew(() => GetAllTheCats(foo));
Task taskB = Task.Factory.StartNew(() => GetAllTheFood(foo));
Task.WaitAll(new [] { taskA, taskB });
// Will continue after both tasks completed
Solution 4
Adding to the other answers, you could do something like:
public PewPew SomeMethod(Foo foo)
{
Task<IList<Cat>> catsTask = GetAllTheCatsAsync(foo);
Task<IList<Food>> foodTask = GetAllTheFoodAsync(foo);
// wait for both tasks to complete
Task.WaitAll(catsTask, foodTask);
return new PewPew
{
Cats = catsTask.Result,
Food = foodTask.Result
};
}
public async Task<IList<Cat>> GetAllTheCatsAsync(Foo foo)
{
await Task.Delay(7000); // wait for a while
return new List<Cat>();
}
public async Task<IList<Food>> GetAllTheFoodAsync(Foo foo)
{
await Task.Delay(5000); // wait for a while
return new List<Food>();
}
Solution 5
You can use the TPL to wait for multiple tasks while they are running. See here.
Like this:
public PewPew SomeMethod(Foo foo) {
IList<Cat> cats = null;
IList<Food> foods = null;
Task[] tasks = new tasks[2] {
Task.Factory.StartNew(() => { cats = GetAllTheCats(foo); }),
Task.Factory.StartNew(() => { food = GetAllTheFood(foo); })
};
Task.WaitAll(tasks);
return new PewPew
{
Cats = cats,
Food = food
};
}
Pure.Krome
Just another djork trying to ply his art in this mad mad world. Tech stack I prefer to use: Laguage: C# / .NET Core / ASP.NET Core Editors: Visual Studio / VS Code Persistence: RavenDB, SqlServer (MSSql or Postgres) Source control: Github Containers: Docker & trying to learn K&'s Cloud Platform: Azure Caching/CDN: Cloudflare Finally: A Tauntaun sleeping bag is what i've always wanted spaces > tabs
Updated on July 09, 2022Comments
-
Pure.Krome almost 2 years
I have a method which does 2 independent pieces of logic. I was hoping I can run them both at the same time .. and only continue afterwards when both those child methods have completed.
I was trying to get my head around the
async/await
syntax but I just don't get it.Here's the code:
public PewPew SomeMethod(Foo foo) { var cats = GetAllTheCats(foo); var food = GetAllTheFood(foo); return new PewPew { Cats = cats, Food = food }; } private IList<Cat> GetAllTheCats(Foo foo) { // Do stuff, like hit the Db, spin around, dance, jump, etc... // It all takes some time. return cats; } private IList<Food> GetAllTheFood(Foo foo) { // Do more stuff, like hit the Db, nom nom noms... // It all takes some time. return food; }
So with that code above, I want to say : go and get all the cats and food at the same time. Once we're finished, then return a new
PewPew
.I'm confused because I'm not sure which classes above are
async
or return aTask
, etc. All of em? just the two private ones? I'm also guessing I need to leverage theTask.WaitAll(tasks)
method, but I'm unsure how to setup the tasks to run at the same time.Suggestions, kind folks?
-
Dimitar Dimitrov almost 11 years
await cTask
andawait fTask
wouldn't that wait for the first then the second ? I mean is it going to be parallel ? -
YK1 almost 11 yearsyes, wait will be sequential, however, tasks have been started in parallel. its not different than task.WaitAll() in terms of time taken to wait.
-
Pure.Krome almost 11 years@YK1 soz buddy - i'm confused. Are you saying that even though you do
var cats = await cTask;
andvar food = await fTask
.. both those tasks will run at the same time (async) and not one -at a time- (sync). -
YK1 almost 11 years@Pure.Krome yes, tasks will start running when you say Task.Run() and not when you say await.
-
Pure.Krome almost 11 years@YK1 i also get a compile error :(
The return type of an async method myst be void, Task or Task<T>
.. and this is for the methodSomeMethod
.. -
YK1 almost 11 years@Pure.Krome: Change it to Task<PewPew>
-
Pure.Krome almost 11 yearswhich then breaks all my existing calls to this method.
-
YK1 almost 11 yearsActually, its not very logical - but reason is here: stackoverflow.com/questions/7010904/…
-
YK1 almost 11 yearsSomewhere at the start of the call tree you either have to accept the task and use Result property instead of await. OR - you have to await from a async void.
-
YK1 almost 11 yearslike Task.WaitAll(), Parallel.Invoke() will block calling thread. This is unlike await.
-
Pure.Krome almost 11 yearsKewl. so then I would do this? (Also, can u update your answer).
var someMethodTask = someMethod(foo); var pewPew = someMethodTask.Result;
-
Dimitar Dimitrov almost 11 years@YK1 well I just tried it and they run in sequence, most certainly.
-
YK1 almost 11 years@DimitarDimitrov: what did you try await on task variable or await on Task.Run() ? Read my answer carefully. Also, you can add a Console.WriteLine between two awaits and in the tasks.
-
Dimitar Dimitrov almost 11 years@YK1
await cTask, await fTask
(one after another), first one finishes unboxes the task and the second one starts. Maybe I'm doing something wrong, not sure. -
Matthew Watson almost 11 years@YK1 Indeed but the op asked "I was hoping I can run them both at the same time .. and only continue afterwards when both those child methods have completed." which this does, of course.
-
Matthew Watson almost 11 yearsI don't know why this is marked as the answer. It doesn't even compile. And if you change it to compile properly, it runs the tasks sequentially, not in parallel.
-
YK1 almost 11 years@MatthewWatson: yes, but he also said,
head around the async/await syntax
- so i've compared between non-blocking await and blocking Wait() -
Matthew Watson almost 11 years@YK1 Aye, but he doesn't need the async, and you answer above doesn't actually run the tasks in parallel - it runs then sequentially.
-
YK1 almost 11 years@MatthewWatson: it will depend which version you use. await on Task.Run() will run sequesntial. But running both Task.Run() before first await will start tasks in parallel
-
Matthew Watson almost 11 years@YK1 Which is why it's much easier to use
Parallel.Invoke()
like I said. -
YK1 almost 11 years@MatthewWatson: true its easy - but it blocks (on UI thread, it will freeze UI) - await is much better because non-blocking - wont freeze UI. I understand it is tad difficult to understand.
-
Matthew Watson almost 11 years@YKI1 It's not difficult to understand (and stop trying to be facetious!). But your answer doesn't demonstrate running two threads in parallel while also awaiting it in the UI without blocking. Anyway, that's all I'm going to say. :)
-
YK1 almost 11 years@MatthewWatson: I am not facetious at all - in fact i had to look up that word on google. As per my understanding, one of the main design goals of await keyword is to wait for async tasks in UI thread without blocking UI thread. Whole WinRT API is designed on this concept.
-
svick almost 11 years@MatthewWatson Assuming we're looking at the same version, then it compiles fine for me and should execute in parallel.
-
Matthew Watson almost 11 years@svick The thing I tried was the part (2) "You could also do this", which seems to operate sequentially. I did finally get the first part to compile by adding all the missing classes, and that does work.
-
svick almost 11 years@MatthewWatson Yeah, but the answer specifically says that part won't run in parallel.
-
Matthew Watson almost 11 years@YK1 Yep, the first part of your answer does work (I +1ed it) Seems I was trying an incorrect version at first.
-
Matthew Watson almost 11 years@svick Yeah true; I wasn't reading it carefully enough! This is indeed a correct answer. :)
-
Zameer Ansari almost 9 years@AdamTal - when to use Tasks and when Async? Does both run methods simultaneously?
-
Adam Tal almost 9 years@zameeramir - async is a compiler implementation of tasks running. Use async when you can but when you're not in an async context you can simply use a Task for running something in a different thread.
-
Zameer Ansari over 8 years@YK1 ...However, this will not start the async tasks simultaneously. Second task will start after the first is over... I never knew about it. Can you please share a link for this please?
-
Zameer Ansari over 8 years@AdamTal Your words are too geeky. Can you simplify them. This entire page is crunching my mind
-
Adam Tal over 8 years@student I wrote it as simple as I can. You seem to miss some knowledge if it's still not clear. Try reading about async and await (msdn.microsoft.com/en-us/library/hh191443.aspx) and about tasks (codeproject.com/Articles/189374/…)
-
Zameer Ansari about 8 years@YK1 Can you please give a suggestion for thread safety about my question
-
Nugs over 6 yearsI just have to say, i have been studying up on async programming for a few weeks now racking my brain on how to loop async calls into non-async code currently in existence and this is the first most comprehensive and easy to understand example of executing non-async method asynchronously. It works beautifully for me and you have helped me avoid updating a bunch of code! Thx!
-
amal50 over 5 yearsinstead of line 4 and 5 from the first code, you can write await Task.WhenAll(cTask , fTask);
-
John Nyingi almost 5 yearsHow do you debug this
-
John Nyingi almost 5 yearsHow do you stop them if you run them infinitely
-
OrangeKing89 over 4 yearsyou can also wrap the other Task.Run and awaits in a Task.Run( async () => { /*code here*/ });
-
McGuireV10 over 4 years@JohnNyingi you'd have to pass a CancellationToken to the methods.