C# ThreadPool: जब हम किसी Method को Delegate Type के माध्‍यम से BeginInvoke() Method का प्रयोग करके Asynchronously Invoke करते हैं, तो CLR कोई एकदम नया Thread Create नहीं करता। बल्कि Efficiency प्राप्त करने के लिए Delegate का BeginInvoke() Method Worker Threads यानी Secondary Threads के एक Pool पर निर्भर करता है, जिसे .NET Runtime द्वारा Maintain किया जाता है। इस Pool के साथ Interact करने के लिए System.Threading Namespace हमें ThreadPool नाम का एक Class Provide करता है।

यदि हम किसी Method Call को किसी Worker Thread यानी Secondary Thread द्वारा Process करने के लिए Worker Thread Pool के Queue में Place करना चाहते हैं, तो हम ThreadPool.QueueUserWorkItem() Method को Use कर सकते हैं।

इस Method को Overload किया गया है ताकि हम इसमें एक System.Object Type का Optional Object Specify कर सकें और WaitCallback Delegate के साथ उसे Parameter की तरह Pass कर सकें। जैसे:

	public static class ThreadPool
	{
		public static bool QueueUserWorkItem(WaitCallback callBack);
		public static bool QueueUserWorkItem(WaitCallback callBack, object state);
	}

WaitCallback Delegate किसी भी ऐसे Object को अपनी Invocation List में Callback Method की तरह Invoke करने के लिए Add कर सकता है, जो कोई भी Value Return न करता हो और System.Object Type का एक Single Parameter Accept करता हो, जो कि Data के Optional State को Represent करता है।

ध्‍यान देने वाली बात ये है कि यदि हम इस QueueUserWorkItem() Method में System.Object Type का कोई Instance Pass नहीं करते, तो CLR स्वयं ही Automatically इसमें null Pass कर देता है।

File Name: ThreadPool.cs
using System;
using System.Threading;

namespace CSharpMultiThreading
{
    class PrintHello
    {
        public void Display()
        {
            for (int i = 1; i < 10; i++)
                Console.Write("  {0}", i);

            Console.WriteLine();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main thread started. ThreadID = {0}", Thread.CurrentThread.ManagedThreadId);

            PrintHello p = new PrintHello();
            WaitCallback workItem = new WaitCallback(PrintTheNumbers);

            // Queue the method ten times.
            for (int i = 0; i < 10; i++)
            {
                ThreadPool.QueueUserWorkItem(workItem, p);
            }
            Console.WriteLine("All tasks queued");
            Console.ReadLine();
        }

        static void PrintTheNumbers(object state)
        {
            PrintHello task = (PrintHello)state;
            task.Display();
        }
    }
}

Output:
Main thread started. ThreadID = 1
All tasks queued
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9
Hello!  1  2  3  4  5  6  7  8  9

इस Program में सबसे पहले हमने निम्न Statement द्वारा PrintHello Type का p नाम का एक Object Create किया है, जिसके Display() Method को हमें Worker Thread द्वारा Execute करना है:

PrintHello p = new PrintHello();

फिर हमने निम्नानुसार Statement द्वारा WaitCallback Delegate Type का एक Object Create किया है और उसे PrintTheNumbers() नाम के Method को Invoke करने के लिए Set किया है:

WaitCallback workItem = new WaitCallback(PrintTheNumbers);

फिर हमने निम्नानुसार Loop द्वारा ThreadPool में दस बार workItem Delegate Object को Queue किया है, ताकि दस Threads एक साथ Execute हो सकें और सभी Threads में Display Method Invoke हो सके:

        for (int i = 0; i < 10; i++)
        {
            ThreadPool.QueueUserWorkItem(workItem, p);
        }

परिणामस्वरूप CLR सभी 10 Threads को ThreadPool में Store करने के बाद जब सभी Threads को One by One Invoke करता है, तो WaitCallback Delegate के माध्‍यम से हर बार निम्नानुसार PrintTheNumbers Method Invoke होता है:

        static void PrintTheNumbers(object state)
        {
            PrintHello task = (PrintHello)state;
            task.Display();
        }

जो PrintHello Type का एक task नाम का Reference Create करता है और उस Reference के लिए Display() Method को Invoke करता है। परिणामस्वरूप हमें उपरोक्तानुसार Output प्राप्त होता है।

Parallel Programming with Task Parallel Library (PTL)

अभी तक हमने Asynchronous Delegates व System.Threading दो Programming Techniques के बारे में जाना जो कि हमें Multi-Threaded .NET Application बनाने की सुविधा Provide करते हैं। ये दोनों ही तरीके अभी तक के सभी .NET Versions में समान रूप से काम करते हैं।

लेकिन .NET 4.0 Framework के Release के साथ ही Microsoft ने Multi-Threaded Programming को Easy बनाने के लिए Task Parallel Library (TPL) नाम की एक नई Library को .NET Platform में Include किया है। जिसका प्रयोग करके हम बडी ही आसानी से Multi-Threaded Applications Create कर सकते हैं। इस Library को System.Threading.Tasks Namespace के रूप में Define किया है।

इसका मतलब ये नहीं है कि यदि हम TPL Use करते हैं, तो हमें System.Threading Namespace के किसी Type को Use करने की जरूरत नहीं है। बल्कि इस Namespace के विभिन्न Types जिनके बारे में हमने इस Chapter में जानकारी प्राप्त की है, को जरूरत के अनुसार उपयोग में लिया जा सकता है।

Task Parallel Library (TPL) .NET Framework 4.0 में Add किया गया सबसे महत्वपूर्ण Feature था। क्योंकि ये हमें दो तरीकों से Multi-Threaded Applications Create करने की सुविधा Provide करता था। पहला ये कि हम इस Library को Use करके ज्यादा आसानी से Multi-Threaded Applications Create कर सकते थे और दूसरा ये कि TPL स्वयं ही Multiple Processors व Multi-Core Processors को Multi-Threaded Applications के लिए Automatically उपयोग में ले लेता था। यानी TPL हमारे Application को Automatically एक से ज्यादा Processors को Use करने के लिए Extend कर देता था।

TPL के अलावा .NET 4.0 में PLINQ को भी Add किया गया था, जो कि दूसरा सबसे महत्वपूर्ण Concept था और ये भी पूरी तरह से Parallel Programming Related Feature ही था, जो Multi-Threaded Applications में Parallel Language Integrated Query (PLINQ) की सुविधा Provide करता था और जब जरूरत होती थी तब Automatically Internally Multiple Processors व Parallelism को Support करता था।

वर्तमान समय में ज्यादातर Software Parallelism पर आधारित हैं और ज्यादातर Computers Multi-Core CUP Based हैं। जिसकी वजह से TPL व PLINQ का महत्व और भी अधिक बढ जाता है। क्योंकि इन Multi-Core CPU Based Machines पर बेहतर Performance प्राप्त करने के लिए जरूरी है कि हमारा Multi-Threaded Application CPU के सभी Cores को बेहतर तरीके से Utilize करे और यही सुविधा TPL व PLINQ Automatically Internally करते हैं।

जबकि हमने पिछले जिन दो तरीकों से Multi-Threaded Programs Create करने के बारे में जाना है, उन तरीकों को Use करके बना, गए Programs Multi-Core Processors को पूरी तरह से Utilize नहीं करते।

हालांकि TPL को System.Threading.Tasks Namespace में Define किया गया है, लेकिन अक्सर हमें जब Synchronization की जरूरत होती है, तब हमें System.Threading Namespace को भी Use करना जरूरी होता है।

C# ThreadPool: System.Threading.Tasks Namespace

इस Namespace को TPL नाम से भी जाना जाता है, जिसमें Defined Types का प्रयोग करके जब हम कोई Multi-Threaded Application Create करते हैं, तो वह Application Automatically हमारे Application के विभिन्न Threads के Workloads को CLR Thread Pool का प्रयोग करते हुए Current Machine पर Available सभी Processors या CPU-Cores पर Distribute कर देता है, जिससे हमारे Program की Performance Automatically Improve हो जाती है।

TPL स्वयं ही विभिन्न प्रकार के Low-Level काम जैसे कि विभिन्न Threads के बीच Work Partitioning, Thread Scheduling, State Management आदि को स्वयं ही Handle कर लेता है।

परिणामस्वरूप हमें ज्यादा बेहतर Performing Multi-Threaded .NET Application प्राप्त होता है, जबकि TPL Use करते हुए पिछले तरीकों से Multi-Threaded Applications Develop करने की तुलना में हमें कम Complexities का ध्‍यान रखना होता है। इस Namespace के विभिन्न Members की Detailed List देखने के लिए हम Visual Studio के Object Browser Utility को Use कर सकते हैं।