.NET में धागे पर tcplistener आने वाले कनेक्शन कैसे प्रसारित करें?

Question

Net.Sockets.TcpListener का उपयोग करते समय, अलग-अलग धागे में आने वाले कनेक्शन (.AceptSocket) को संभालने का सबसे अच्छा तरीका क्या है?

विचार एक नया थ्रेड शुरू करना है जब एक नया आने वाला कनेक्शन स्वीकार किया जाता है, जबकि टीसीप्लिस्टर फिर आने वाले कनेक्शन के लिए उपलब्ध रहता है (और प्रत्येक नए आने वाले कनेक्शन के लिए एक नया धागा बनाया जाता है)। कनेक्शन की उत्पत्ति करने वाले क्लाइंट के साथ सभी संचार और समाप्ति थ्रेड में संभाली जाएगी।

वीबी.नेट कोड के उदाहरण सी # की सराहना की जाती है।

Answer 1

कोड है कि मैं इस तरह दिखता है का उपयोग कर:

class Server 
{ 
    private AutoResetEvent connectionWaitHandle = new AutoResetEvent(false); 

    public void Start() 
    { 
    TcpListener listener = new TcpListener(IPAddress.Any, 5555); 
    listener.Start(); 

    while(true) 
    { 
     IAsyncResult result = listener.BeginAcceptTcpClient(HandleAsyncConnection, listener); 
     connectionWaitHandle.WaitOne(); // Wait until a client has begun handling an event 
     connectionWaitHandle.Reset(); // Reset wait handle or the loop goes as fast as it can (after first request) 
    } 
    } 


    private void HandleAsyncConnection(IAsyncResult result) 
    { 
    TcpListener listener = (TcpListener)result.AsyncState; 
    TcpClient client = listener.EndAcceptTcpClient(result); 
    connectionWaitHandle.Set(); //Inform the main thread this connection is now handled 

    //... Use your TcpClient here 

    client.Close(); 
    } 
} 

Answer 2

मैं थ्रेडपूल का उपयोग करूंगा, इस तरह आपको हर बार एक नया धागा शुरू नहीं करना पड़ेगा (क्योंकि यह थोडा महंगा है)। मैं furhter कनेक्शन के लिए अनिश्चितता से भी इंतजार नहीं करूँगा, क्योंकि ग्राहक अपने कनेक्शन बंद नहीं कर सकते हैं। आप प्रत्येक बार क्लाइंट को उसी थ्रेड पर रूट करने की योजना कैसे बनाते हैं?

क्षमा करें, नमूना नहीं है।

Answer 3

O'Reilly C# 3.0 कुकबुक में एक शानदार उदाहरण है। आप http://examples.oreilly.com/9780596516109/CSharp3_0CookbookCodeRTM.zip

Answer 4

से संबंधित स्रोत डाउनलोड कर सकते हैं। मुझे विश्वास है कि आप इसे .NET में किसी भी अन्य एसिंक्रोनस ऑपरेशन के रूप में करते हैं: आप इस मामले में BeginAcceptSocket में BeginXxx संस्करण को कॉल करते हैं। आपका कॉलबैक थ्रेड पूल पर निष्पादित होगा।

पूल किए गए थ्रेड आम तौर पर थ्रेड-प्रति-कनेक्शन से काफी बेहतर होते हैं: एक बार जब आप कनेक्शन के कुछ दस गुना अधिक हो जाते हैं, तो सिस्टम वास्तविक काम करने की तुलना में धागे के बीच स्विच करने में बहुत कठिन काम करता है। इसके अलावा, प्रत्येक धागे का अपना ढेर होता है जो आम तौर पर आकार में 1 एमबी होता है (हालांकि यह लिंक झंडे पर निर्भर करता है) जिसे 2 जीबी वर्चुअल एड्रेस स्पेस (32-बिट सिस्टम पर) में पाया जाना चाहिए; अभ्यास में यह आपको 1000 से कम धागे तक सीमित करता है।

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

Answer 5

मैं एक भिन्न दृष्टिकोण का सुझाव देना चाहता हूं: मेरा सुझाव केवल दो धागे का उपयोग करता है। * इनकमिंग कनेक्शन के लिए एक थ्रेड चेक। * जब कोई नया कनेक्शन खोला जाता है तो यह जानकारी साझा डेटा संरचना में लिखी जाती है जिसमें सभी मौजूदा खुले कनेक्शन होते हैं। * दूसरा धागा बताता है कि डेटा संरचना और प्रत्येक खुले कनेक्शन के लिए भेजा गया डेटा प्राप्त होता है और उत्तर भेजता है।

यह समाधान अधिक स्केल करने योग्य थ्रेड-वार है और अगर लागू किया गया है तो सही प्रदर्शन होना चाहिए, फिर खुले कनेक्शन के बाद एक नया धागा खोलना चाहिए।