जावा सॉकेट: एक सर्वर और एकाधिक ग्राहक

Question

इसलिए मैंने जावा में एक मूल क्लाइंट-सर्वर प्रोग्राम बनाया। यह इस तरह से शुरू होती है:

1. ग्राहक सर्वर को
2. सर्वर क्लाइंट का नाम
3. क्लाइंट का नाम के साथ प्रतिक्रिया के लिए पूछता है
4. सर्वर को बधाई दी क्लाइंट
5. इस के बाद से जोड़ता है, ग्राहक बोलते हैं और सर्वर को दोहराता है शब्द

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

यहाँ है कोड मैं उपयोग कर रहा हूँ:

import java.net.*; 
import java.io.*; 

public class Server extends Thread { 
    private ServerSocket listener; 

    public Server(int port) throws IOException { 
    listener = new ServerSocket(port); 
    } 

    public void run() { 
    while(true) { 
     try { 
     Socket server = listener.accept(); 
     DataOutputStream out = new DataOutputStream(server.getOutputStream()); 
     out.writeUTF("What is your name?"); 
     DataInputStream in = new DataInputStream(server.getInputStream()); 
     String user_name = in.readUTF(); 
     out.writeUTF("Hello "+user_name); 
     while(true) { 
      String client_message = in.readUTF(); 
      out.writeUTF(client_message); 
     } 
     } 
     catch(IOException e) { 
     e.printStackTrace(); 
     } 
    } 
    } 

    public static void main(String[] args) { 
    int port = 6006; 
    try { 
     Thread t = new Server(port); 
     t.start(); 
    } catch(IOException e) { 
     e.printStackTrace(); 
    } 
    } 
} 

कोई व्याख्या कर सकते हैं मैं गलत क्या कर रहा हूँ?

मैंने थ्रेड को विस्तारित करने के बजाए रननेबल का उपयोग करने पर ध्यान दिया है, लेकिन मैं वहां और भी अधिक समस्याओं में भाग गया, इसलिए मैं इस प्रयास के साथ प्रयास करना और काम करना चाहता हूं।

Answer 1

आने वाले कनेक्शन केवल listener.accept(); लाइन द्वारा संभाले जाते हैं। लेकिन जब आप एक क्लाइंट जुड़े हुए हैं, तो आप थोड़ी देर लूप में फंस गए हैं। यदि आपको उच्च भार की उम्मीद है तो आपको Thread (या Runnable पर ExecutorService पर निष्पादित करने की आवश्यकता है), और इसे शुरू करें, फिर तत्काल अगला कनेक्शन स्वीकार करें।

Answer 2

संक्षेप में, यह गलत हो रहा है।

1. आप सर्वर के रूप में बिल्कुल एक थ्रेड का उपयोग कर रहे हैं। इसी प्रकार तुम अब क्या है करने के लिए है, लेकिन बजाय - सर्वर:

   दो वर्गों 1 बनाएँ:

2. इस सूत्र को अवरुद्ध करने जब आप कॉल listener.accept()

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

या:

आप एक TCP सर्वर के बजाय एक यूडीपी सर्वर प्रारंभ, और यह सब बात तो नहीं होगा, लेकिन यह है कि इस विशिष्ट प्रश्न के दायरे से बाहर है।