क्या मुझे थ्रेड या कार्य का उपयोग करना चाहिए - एकाधिक क्लाइंट सिमुलेशन

Question

मैं एक क्लाइंट सिमुलेशन प्रोग्राम लिख रहा हूं जिसमें सभी सिम्युलेटेड क्लाइंट सर्वर के विरुद्ध कुछ पूर्वनिर्धारित दिनचर्या चलाते हैं - जो चार उदाहरणों के साथ एज़ूर में चल रहा एक वेब सर्वर है।

सभी अनुरूपित क्लाइंट सर्वर से कनेक्ट होने के बाद समान दिनचर्या चलाते हैं।

किसी भी समय मैं अपने कार्यक्रम का उपयोग कर 300 से 800 क्लाइंट अनुकरण करना चाहता हूं।

मेरा प्रश्न है: क्या मुझे क्लाइंट क्लास के एन उदाहरण बनाना चाहिए और उन्हें एन अलग-अलग धागे में चलाएं? या

क्या मुझे चीजों को करने के लिए कार्य पुस्तकालय का उपयोग करना चाहिए?

Answer 1

आपको निश्चित रूप से 800 धागे नहीं बनाना चाहिए।

चलो यहाँ एक कदम उठाएं। आपके पास एक "सर्वर" नामक डिवाइस है जो "क्लाइंट" से "अनुरोध" लेता है और उन ग्राहकों को "प्रतिक्रियाएं" भेजता है। आइए मान लीजिए कि अनुरोध डाकघर द्वारा दिए गए कागज़ के टुकड़े हैं, और प्रतिक्रियाएं किताबों वाले बक्से हैं, जो डाकघर द्वारा भी वितरित की जाती हैं।

आप सर्वर का परीक्षण करने के लिए 800 क्लाइंट अनुकरण करना चाहते हैं।

मान लीजिए कि एक धागा एक व्यक्ति है और एक प्रोसेसर कुर्सी है। कुर्सी पर बैठे एक व्यक्ति केवल काम कर सकता है।

800 धागे बनाना 800 लोगों को भर्ती करने और सर्वर पर एक पत्र भेजने के बराबर है। लेकिन आपके पास केवल चार कुर्सियां ​​हैं, इसलिए उन 800 लोगों को कुर्सियों का उपयोग करके मोड़ लेना होगा।

यह वास्तविक जीवन में लुडिकस समाधान होगा। थ्रेड, जैसे लोगों, बेहद महंगा हैं। आपको बनाए गए धागे की संख्या को कम करना चाहिए।

तो, क्या आप कार्य कारखाने के माध्यम से 800 कार्यों को बना सकते हैं और टीपीएल को आपके लिए समानांतर बना सकते हैं?

नहीं, आपको ऐसा नहीं करना चाहिए। टीपीएल में लोगों (धागे) का एक पूल है जो आकर्षित करने के लिए है, और यह चीजों की व्यवस्था करने की कोशिश करता है ताकि वहां बैठने के लिए कुर्सियों की तुलना में पेरोल पर कोई और लोग न हों। लेकिन आपका काम "कुर्सी बाध्य" नहीं है - - लोग कुर्सी पर बैठने जा रहे हैं, सर्वर से अनुरोध भेजते हैं, और फिर वापस आने के जवाब की प्रतीक्षा करते समय कुर्सी से बाहर निकलते हैं। जबकि वे प्रतीक्षा कर रहे हैं, टीपीएल को अब अतिरिक्त कार्यों की सेवा के लिए अधिक लोगों को किराए पर लेना है।

वेब सर्वर मारना I/O बाध्य है; आपको केवल उन कार्यों के लिए थ्रेड-पूल किए गए कार्यों को बनाना चाहिए जो सीपीयू बाध्य हैं।

सही समाधान दो लोगों को किराए पर लेना है।

एक व्यक्ति - "आई/ओ पूरा करने वाला धागा" - मेलबॉक्स में अनुरोध छोड़ने के अलावा कुछ भी नहीं करता है और आने वाले पैकेजों की जांच करता है। दूसरा व्यक्ति - "अनुकरण" व्यक्ति - 800 क्लाइंट अनुकरण करने के लिए सही "शेड्यूल" क्या काम करता है। सिमुलेशन व्यक्ति शेड्यूल का काम करता है, और फिर सो जाता है। वह सर्वर पर एक और अनुरोध भेजने का समय है जब वह उठता है। जब वह उठती है, तो वह मेलबॉक्स में इस पत्र को छोड़ने के लिए I/O पूर्णता धागा बताती है, और जब प्रतिक्रिया आती है तो उसे उठाना पड़ता है। तब वह सो जाती है जब तक कि यह कोई अन्य अनुरोध भेजने का समय न हो, या प्रतिक्रिया उसमें आता है कि सत्यापित करने की जरूरत है।

आपको क्या करना चाहिए (1) सी # 5 का बीटा संस्करण प्राप्त करें और सर्वर को अनुरोध भेजने वाले कार्यों को बनाने के लिए async/await का उपयोग करें, और उसके बाद संदेश लूप पर नियंत्रण प्राप्त करें जब तक कि यह किसी अन्य को भेजने का समय न हो अनुरोध या प्रतिक्रिया आती है। या, यदि आप सी # 5 का उपयोग नहीं करना चाहते हैं, तो आपको कार्य पूरा करने का स्रोत बनाना चाहिए, और सही कार्यवाही करने वाले कार्यों को सेट करना चाहिए।

संक्षेप में: कई समांतर I/O कार्यों को संभालने का सही तरीका है धागे की एक बहुत छोटी संख्या बनाना, जिनमें से प्रत्येक एक समय में बहुत कम काम करता है। I/O पूर्णता धागा I/O के ब्योरे को संभालने दें। 800 अक्षरों को भेजने के अनुकरण के लिए आपको 800 लोगों को किराए पर लेने की आवश्यकता नहीं है। किराया दो लोग, मेलबॉक्स देखने के लिए और अक्षरों को लिखने के लिए एक।

Answer 2

मैं कार्य पुस्तकालय का उपयोग करता हूं और कार्य पुस्तकालय को आपके लिए सभी थ्रेडिंग को संभालने देता हूं। आप 800 धागे को स्पिन नहीं करना चाहते हैं। यह एक बुरा विचार है कि एक समय में कई साथ-साथ थ्रेड चल रहे हैं, यहां एक और स्टैक ओवरफ्लो प्रश्न है जो इसके बारे में बात करता है: Maximum number of threads in a .NET app?

Answer 3

इस मामले में उत्तर इतना आसान नहीं है। यह वास्तव में कैसे आप अपने ग्राहकों को नकली होना चाहते हैं पर निर्भर करता है:

1. आप 800 जुड़े ग्राहकों करना चाहते हैं, लेकिन जरूरी नहीं कि एक ही समय में, यह एक अच्छा विचार Task रों उपयोग करने के लिए है। वे हल्के वजन वाले हैं और अंतर्निहित ThreadPool का कुशल उपयोग करते हैं।

2. यदि आप वास्तव में ग्राहकों को समानांतर में बिल्कुल चाहते हैं, तो मुझे डर है कि वास्तव में धागे से बचने का कोई तरीका नहीं है। 800 लाइटवेट एक साथ निष्पादन कार्यों को पाने के लिए कोई जादुई तरीका नहीं है। Task अमूर्त हल्का वजन ठीक है क्योंकि यह थ्रेड पूल का उपयोग करता है। इसका मतलब है कि कई कार्यों को वास्तविक धागे की एक छोटी संख्या में मैप किया जाता है। लेकिन, ज़ाहिर है, इसका तात्पर्य है कि वे वास्तव में समानांतर में नहीं चलते हैं, लेकिन जब भी संभव हो तो दौड़ने के लिए निर्धारित होते हैं। ThreadPool में अधिकतम 250 (AFAIK) के धागे हैं, इसलिए यदि आप Task एस का उपयोग करते हैं तो 250 से अधिक "क्लाइंट" वास्तव में निष्पादित नहीं होंगे। समाधान अधिकतम धागे 800 पर सेट है, लेकिन इस बिंदु पर यह क्लासिक धागे का उपयोग करने जैसा ही है।

Answer 4

इस application domains आपकी सर्वश्रेष्ठ शर्त है।

एक आवेदन डोमेन अलगाव की रनटाइम इकाई है जिसमें एक .NET अनुप्रयोग निष्पादित होता है। यह एक प्रबंधित मेमोरी सीमा प्रदान करता है, एप्लिकेशन कॉन्फ़िगरेशन सेटिंग्स के लिए एक कंटेनर के साथ-साथ वितरित अनुप्रयोगों के लिए संचार इंटरफ़ेस प्रदान करता है।

प्रत्येक .NET एप्लिकेशन आमतौर पर केवल एक एप्लिकेशन डोमेन होस्ट करता है जो सीएलआर द्वारा स्वचालित रूप से बनाया जाता है जब दी गई प्रक्रिया/प्रोग्राम शुरू होता है। एक प्रक्रिया/कार्यक्रम में अतिरिक्त एप्लिकेशन डोमेन बनाने के लिए यह कभी-कभी उपयोगी होता है (जैसे आपके मामले में)। कई अनुप्रयोग डोमेन का उपयोग संचार जटिलताओं से बचाता है और कई अलग-अलग प्रक्रियाओं का उपयोग करके उत्पन्न होता है और आपके कार्यों को अलगाव प्रदान करता है।

जो आप चाहते हैं उसके लिए आपके पास दो विकल्प हैं।

1. उसी डोमेन में अलग थ्रेड पर एक्स थ्रेड प्रारंभ करें।

इसका मतलब यह होगा कि आप धागे की सुरक्षित किया जा रहा है, जो एकाधिक लॉगिन का अनुकरण के रूप में इस तरह के एक कार्य के साथ बहुत मुश्किल होगा की बहुत थके हुए होना होगा, ग्राहकों आदि

1. प्रारंभ एक्स धागे अनुकरण उसी प्रक्रिया में प्रत्येक अपने आवेदन डोमेन में।

यह प्रत्येक स्पून थ्रेड को अलग रखेगा और होस्टिंग एप्लिकेशन/प्रोग्राम द्वारा एक्सेस करना आसान होगा। आप सभी को होने से एक्स अनुकरण में एक्स अलग आवेदन डोमेन, प्रत्येक डोमेन पृथक और स्थिर वर्ग के सदस्यों आदि के माध्यम से किसी अन्य ग्राहक के अनुकरण के साथ हस्तक्षेप करने में असमर्थ होगा

निम्नलिखित जोसेफ अल्बहारी की किताब C# 4.0 In a Nutshell से एक उद्धरण द्वारा सहायता प्राप्त है जो मैं दृढ़ता से हो रही सलाह देते हैं:

40 समवर्ती ग्राहक सिमुलेशन का एक उदाहरण आप के लिए काम का हो सकता:

class program 
{ 
    static void main() 
    { 
     // Create 40 domains and 40 threads. 
     AppDomain[] domains = new AppDomain[40]; 
     Thread[] thread = new Thread[40]; 

     for (int i = 0; i < 40; i++) 
     { 
      domains[i] = AppDomain.CreateDomain("Client Simulation " + i); 
      thread[i] = new Thread(SimulateClientInOtherDomain); 
     } 

     // Start all threads, passing to each thread its app domain. 
     for (int j = 0; j < 40; j++) 
      threads[j].Start(domains[j]); 

     // Wait for the threads to finish. 
     for (int k = 0; k < 40; k++) 
      threads[k].Join(); 

     // Unload the application domains. 
     for (int l = 0; l < 40; l++) 
      AppDomain.Unload(domains[l]); 
    } 

    // Thread start with input of with domain to run on/in. 
    static void SimulateClientInOtherDomain(object domain) 
    { 
     ((AppDomain)domain).DoCallBack(Simulate); 
    } 

    static void Simulate() 
    { 
     Client simClient1 = new Client("Bill", "Gates", ...); 
     simClient1.Simulate(); 
    } 
} 

मुझे आशा है कि इस मदद करता है।