CODEWITHSUNDEEP
c#.netuwp
Kenneth Witham
Kenneth Witham

Reputation: 174

UWP handling many threads

So I am developing a UWP application that has a large number of threads. Previously I would start all the threads with System.Threading.Tasks.Task.Run(), save their thread handles to an array, then Task.WaitAll() for completion and get the results. This currently is taking too much memory though.

I have changed my code to only wait for a smaller amount of threads and copy their results out before continuing on to more of the threads. Since UWP the UWP implementation of Task does not implement IDisposable, what is the proper way to signal the framework that I am done with a task so it can be garbage collected? I would like to read out the results of the treads after a certain number of them come in and dispose of the threads resources to make space for the next threads.

Thanks so much!

Upvotes: 0

Views: 516

Answers (2)

André B
André B

Reputation: 1709

Just to point out an issue which might be degrading the performance of your application: You are deliberately blocking the thread until all Tasks complete rather than actually await for them. That would make sense, if you are not performing Asynchronous work inside them, but if you are, you should definitely switch to:

Task.WhenAll rather than Task.WaitAll , such as this:

List<Tasks> tasks = new List<Tasks> { Method1(), Method2(), ... };
Task result = await Task.WhenAll(tasks);

This way, you are actually leveraging the asynchrony of your app, and you will not block the current thread until all the tasks are completed, like Task.WaitAll() does.

Since you are utilizing the Task.Run() method, instead of the Task.Factory.StartNew(), the TaskScheduler used is the default, and utilizes Threads from the Thread Pool. So you will not actually end up blocking the UI thread, but blocking many Thread Pool threads, is also not good.

Taking from Microsoft documentation, for one of the cases where Thread Pools should not be used:

You have tasks that cause the thread to block for long periods of time. The thread pool has a maximum number of threads, so a large number of blocked thread pool threads might prevent tasks from starting.

Edit:

I do not need anything else but I will look in to that! Thanks! So is there any way I can get it to run the Tasks like a FIFO with just the API's available with the default thread pool?

You should take a look, into Continuations

A continuation is nothing else other than a task which is activated whenever it's antecedent task/tasks have completed. If you have specific tasks which you only want to execute after another task has completed you should take a look into Continuations, since they are extremely flexible, and you can actually create really complex flow of Tasks to better suit your needs.

Upvotes: 1

Ignacio Soler Garcia
Ignacio Soler Garcia

Reputation: 21855

Garbage collection on a .Net application always works the same, when a variable is not needed anymore (out of scope) it is collected.

Why do you think the threads are consuming the memory? It is much likely than the process inside the threads is the one consuming the memory.

Upvotes: 0

Related Questions