Prizes & Awards
My Profile
Active Members
TodayLast 7 Days
more...
|
Resources » Articles » ASP.NET/Web Applications »
Multi Threading
|
What Is Multithreading?
Multithreading is a technique that can be used to perform time consuming tasks in a separate additional thread other than the main application thread.
When you, for example, have a time-consuming function, you may need to call this function as a response of a button click. Now, instead of freezing all your application waiting for this function to return / to finish, you can create a new thread and assign this function to. When you do this, your application interface will not be blocked and you can use it to perform other tasks. At the same time, your time-consuming task is being carried out in the background.
You can think of it as the two threads: the main one, and the newly created one. Both are running in parallel, and this improves the performance and responsiveness of your application.
Advantages and Disadvantages of Using Multithreading
Despite improving your application's performance, and avoiding unresponsive user interface, multithreading has the following disadvantages:
* There is a runtime overhead associated with creating and destroying threads. When your application creates and destroys threads frequently, this overhead affects the overall application performance.
* Having too many threads running at the same time decreases the performance of your entire system. This is because your system is attempting to give each thread a time slot to operate inside.
* You should design your application well when you are going to use multithreading, or otherwise your application will be difficult to maintain and extend.
* You should be careful when you implement a multithreading application, because threading bugs are difficult to debug and resolve.
Notes:
* Each time a thread is created, a certain amount of memory is consumed to hold this thread context information. Hence, the number of threads that can be created is limited by the amount of available memory.
* More threads does not mean a faster responsive application, instead it can decrease the performance of your application.
The Thread Pool
Instead of creating a thread each time we need one, and then destroying it after finishing, the .NET framework introduces the concept of thread pool. In the thread pool technique, and instead of creating a new thread whenever you need one, your application will obtain a thread from the thread pool. After that obtained thread completes its task, it will be returned to the thread pool instead of destroying it - waiting for the next acquiring. This reusability increases the overall application performance, and reduces the cost of excessive thread creation and termination.
To make use of this technique, you need to use the System.Threading.ThreadPool class. The thread pool will be created the first time you use it. The number of total threads in this pool is restricted by default to 25 threads. This means that all of these 25 threads may be busy at some point. If you need to acquire a new thread at this point, your task will be scheduled waiting for a thread to finish its task and return to the pool.
Benefits of Using the Thread Pool
Using the thread pool is the easiest technique you can use to create a multithreaded application for the following reasons:
* You do not have to create, manage, schedule, and terminate your thread, the thread pool class do all of this for you.
* There is no worries about creating too many threads and hence affecting system performance. Thread pool size is constrained by the .NET runtime. The number of threads you can use at the same time is limited.
* You need to write less code, because the .NET framework manages your thread internally with a set of well tested, and bug free routines.
Limitations of Using the Thread Pool
Despite the ease of use, the thread pool has the following limitations or disadvantages when compared to manually managing your threads:
* With thread pool, you have no control over the state and priority of the thread.
* With thread pool, you can not give a stable identity to your thread and keep tracking it.
* When submitting a process to the thread pool, you have no idea when the process will be executed. Your process may be delayed when there are high demand on the thread pool.
* The thread pool is not suitable when you want to run two tasks or processes using two threads, and need these two tasks to be processed simultaneously in a deterministic fashion.
* The .NET framework uses the thread pool for asynchronous operations, and this places additional demand on the limited number of available threads.
* Despite of robust application isolation, there are situations where your application code can be affected by another application code.
|
Responses
|
| Author: greeny_1984 03 Nov 2009 | Member Level: Diamond Points : 1 | Hi,
Nice article ..
My suggestion for you is when ever you give headings in a article
try to high light them using html tags like font or bold
regards,
greeny_1984
|
|