C # .NET फर्स्ट स्टेप्स में थ्रेड्स

प्रिय पाठकों, इस लेख में मैं मल्टीटास्किंग प्रोग्रामिंग के लिए इस तरह के एक महत्वपूर्ण टूल के बारे में बात करना चाहता हूं। .NET पर्यावरण, मल्टीथ्रेडिंग के रूप में। इस आलेख में पृष्ठभूमि जानकारी शामिल है, और इसका उद्देश्य C # में मल्टीथ्रेडिंग की मूल बातें जल्दी से सीखना है। हालांकि, मैं समानांतर में चल रहे कार्यों के लाभों के बारे में बात नहीं करूंगा, और कोड उदाहरण पर आगे बढ़ूंगा।

using System; using System.Threading; //      namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Thread myThread = new Thread(func); //    (Thread) myThread.Start(); //  for (int i = 0; i < 10; i++ ) { Console.WriteLine(" 1  " + i); Thread.Sleep(0); } Console.Read(); //   } //     static void func() { for (int i = 0; i < 10; i++) { Console.WriteLine(" 2  " + i.ToString()); Thread.Sleep(0); } 

इस कार्यक्रम में आपको क्या ध्यान देना चाहिए। यह मुख्य रूप से System.Threading नाम स्थान है। इस नेमस्पेस में ऐसी कक्षाएं हैं जो मल्टीथ्रेडेड प्रोग्रामिंग का समर्थन करती हैं। और वह वह जगह है जहां थ्रेड क्लास निहित है, जिसे हम बाद में कोड में उपयोग करते हैं।
आगे हम एक स्ट्रीम ऑब्जेक्ट बनाते हैं।

 Thread myThread = new Thread(func); 

इस वर्ग के निर्माता को फ़ंक्शन के नाम को शून्य से पारित करने की आवश्यकता होती है, जिसे वास्तव में समानांतर धागे में कहा जाएगा। उसके बाद, हम नए बनाए गए स्ट्रीम के अंदर परिभाषित स्टार्ट () पद्धति का उपयोग करके अपनी स्ट्रीम शुरू करते हैं।

इसलिए, मुख्य और द्वितीयक सूत्र एक साथ लगभग समान कोड निष्पादित करते हैं, वे 9 (जैसा कि खरोंच से हुआ), अपने स्वयं के नंबर पर कॉल करने से पहले गिनते हैं। स्थिर थ्रेड पर ध्यान दें। सो (0) विधि। यह उस धागे को निलंबित कर देता है जो इसे पैरामीटर में निर्दिष्ट मिलीसेकंड की संख्या के लिए पैदा करता है। लेकिन इस मामले में, पैरामीटर 0 को पास किया जाता है। इसका मतलब है कि थ्रेड को निष्पादित करने के लिए दूसरे थ्रेड को सक्षम करने के लिए रोकना होगा।

और ताकि कंसोल समय से पहले बंद न हो, हम कीबोर्ड इनपुट ( Console.Read ) की प्रतीक्षा करेंगे। नतीजतन, आपका प्रोग्राम निम्नलिखित को कंसोल में आउटपुट करेगा:
धागा 1 आउटपुट 0
स्ट्रीम 2 आउटपुट 0
स्ट्रीम 1 आउटपुट 1
स्ट्रीम 1 आउटपुट 2
स्ट्रीम 1 आउटपुट 3
स्ट्रीम 2 आउटपुट 1
<...> आदि

हालांकि हर बार आउटपुट परिणाम अलग होगा। यह कई कारकों पर निर्भर करता है। यह विचार करने योग्य है कि दो प्रकार के प्रवाह हैं: प्राथमिकता और पृष्ठभूमि। प्राथमिकता प्रवाह होने पर पृष्ठभूमि थ्रेड्स स्वचालित रूप से समाप्त हो जाते हैं। डिफ़ॉल्ट रूप से, मुख्य फ़ंक्शन प्राथमिकता थ्रेड में लॉन्च किया गया है, और शेष धागे पृष्ठभूमि में बनाए गए हैं। इसलिए हमें यह सुनिश्चित करना चाहिए कि मुख्य धागा डेरिवेटिव के अंत से पहले समाप्त न हो। इसे रोकने के लिए, हम IsAlive फ़ील्ड का उपयोग कर सकते हैं, जो कि स्ट्रीम सक्रिय होने पर वापस लौटता है। या ज्वाइन () विधि, जो उस धागे का कारण बनता है, जिसमें इसे उस धागे के पूरा होने का इंतजार करने के लिए कहा जाता है, जो उसका है।

हालांकि, हम स्वयं के प्रकारों को बदल सकते हैं। IsBackground स्ट्रीम प्रॉपर्टी यह निर्धारित करती है कि स्ट्रीम बैकग्राउंड है या नहीं। इस प्रकार, हम प्रवाह को प्राथमिकता बना सकते हैं। myThread.IsBackground = false; हालांकि, हमें मुख्य विधि के अंदर एक नया धागा बनाने की आवश्यकता नहीं है। आइए एक वर्ग बनाएं जो अपने स्वयं के निर्माणकर्ता में एक नया सूत्र खोलेगा। हमने जो वर्ग बनाया है वह गिनती से निपटना जारी रखेगा, लेकिन इस बार यह निर्दिष्ट संख्या तक गिना जाएगा, जो कि मापदंडों को धारा में प्रवाहित करेगा।

 using System; using System.Threading; namespace ConsoleApplication1 { class Program { class myThread { Thread thread; public myThread(string name, int num) //          { thread = new Thread(this.func); thread.Name = name; thread.Start(num);//    } void func(object num)// ,   { for (int i = 0;i < (int)num;i++ ) { Console.WriteLine(Thread.CurrentThread.Name + "  " + i); Thread.Sleep(0); } Console.WriteLine(Thread.CurrentThread.Name + " "); } } static void Main(string[] args) { myThread t1 = new myThread("Thread 1", 6); myThread t2 = new myThread("Thread 2", 3); myThread t3 = new myThread("Thread 3", 2); Console.Read(); } } } 

आइए इस उदाहरण का विश्लेषण करें। हमारे myThread क्लास का कंस्ट्रक्टर 2 पैरामीटर लेता है: एक पंक्ति जिसमें हम थ्रेड का नाम निर्धारित करते हैं, और जिस संख्या में गणना को लूप में रखा जाएगा। कंस्ट्रक्टर में, हम इस ऑब्जेक्ट के फंक फ़ंक्शन से जुड़ा एक धागा बनाते हैं। इसके बाद, हम निर्मित स्ट्रीम के नाम क्षेत्र का उपयोग करके अपनी स्ट्रीम को नाम देते हैं। और हम अपने प्रवाह को शुरू करते हैं, प्रारंभ फ़ंक्शन को तर्क देते हैं।

ध्यान दें कि एक धारा द्वारा बुलाया गया फ़ंक्शन केवल 1 तर्क ले सकता है, और केवल प्रकार ऑब्जेक्ट। फंक फ़ंक्शन में, लूप के लिए संख्या एक तर्क के रूप में इसे पारित कर देती है, और धारा समाप्त हो जाती है। मुख्य फ़ंक्शन में, हम 3 परीक्षण ऑब्जेक्ट बनाते हैं, जिनमें से ऑपरेशन कंसोल पर निम्न पाठ प्रदर्शित करता है।

धागा 1 आउटपुट 0
धागा 1 आउटपुट 1
थ्रेड 2 आउटपुट 0
थ्रेड 2 आउटपुट 1
थ्रेड 2 आउटपुट 2
थ्रेड 2 खत्म हो गया है
<...>

इस उदाहरण के साथ, मैं अपना लेख समाप्त करना चाहता हूं। और यद्यपि धाराओं के साथ काम करने के कई साधन मेरे द्वारा अप्रभावित रहे, मुझे आशा है कि मेरे द्वारा दी गई जानकारी उपयोगी होगी।