जावा और नागल चित्रण

Question

मैं एक सरल क्लाइंट-सर्वर प्रोग्राम में नागल एल्गोरिदम को चित्रित करने की कोशिश कर रहा हूं। लेकिन मैं इसे काफी समझ नहीं सकता, या इसे स्पष्ट रूप से मेरे लिए मुद्रित कर सकता हूं।

मेरे उदाहरण में, क्लाइंट सिर्फ int से 1 से 1024 उत्पन्न करता है और इन्हें सर्वर पर भेजता है। सर्वर सिर्फ इन int को हेक्स स्ट्रिंग में परिवर्तित करता है और उन्हें वापस क्लाइंट को भेजता है।

मैं जो कुछ भी बदलता हूं, वही परिणाम एक ही परिणाम के साथ समाप्त होता है। Int को 256 int के ब्लॉक में भेजा गया है और नाराज है .. मैंने परिवर्तन देखने के लिए दोनों तरफ setTcpNoDelay (true) की कोशिश की लेकिन यह मेरे कंसोल में एक ही परिणाम देता है। (लेकिन वायरसहार्क में नहीं, मुझे सर्वर और क्लाइंट के बीच भेजे गए पैकेट की मात्रा में एक बड़ा अंतर दिखाई देता है) लेकिन मेरा लक्ष्य इसे कंसोल में देखने में सक्षम होना है, मुझे लगता है कि ऑब्जेक्टऑटपुटस्ट्रीम का कुछ बफर है या सब कुछ होल्डिंग ऊपर?

जब मैं output = new PrintWriter(client.getOutputStream(), true) को falseबदल (true या false: autoFlush - बूलियन, अगर true, println, printf, या format तरीकों उत्पादन बफर फ्लश) अपने सर्वर को वापस किसी भी उत्पादन नहीं देता ग्राहक अब और।

असल में मेरा लक्ष्य केवल कंसोल में इनपुट/आउटपुट में अंतर को स्पष्ट रूप से देखने के लिए, टीसीपीएनओडेले सेट करने के लिए तर्क के रूप में सर्वर और/या क्लाइंट के साथ सही या गलत देना है। मैं सब कुछ इस्तेमाल करने के बारे में निश्चित नहीं हूं इसलिए इसे साफ़ करने में कोई मदद स्वागत है।

सर्वर:

package Networks.Nagle; 

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

public class NagleDemoServer 
{ 
    private static ServerSocket serverSocket; 
    private static final int PORT = 1234; 

    public static void main(String[] args) throws IOException 
    { 
     int received = 0; 
     String returned; 
     ObjectInputStream input = null; 
     PrintWriter output = null; 
     Socket client; 

     try 
     { 
      serverSocket = new ServerSocket(PORT); 
      System.out.println("\nServer started..."); 
     } 
     catch (IOException ioEx) 
     { 
      System.out.println("\nUnable to set up port!"); 
      System.exit(1); 
     } 

     while(true) 
     { 
      client = serverSocket.accept(); 
      client.setTcpNoDelay(true); 

      System.out.println("\nNew client accepted.\n"); 

      try 
      { 
       input = new ObjectInputStream(client.getInputStream()); 
       output = new PrintWriter(client.getOutputStream(), true); 

       while(true) 
       { 
        received = input.readInt(); 
        returned = Integer.toHexString(received); 
        System.out.print(" " + received); 
        output.println(returned.toUpperCase()); 

       } 
      } 
      catch(EOFException eofEx) 
      { 
       output.flush(); 
       System.out.println("\nEnd of client data.\n"); 
      } 
      catch(SocketException sEx) 
      { 
       System.out.println("\nAbnormal end of client data.\n"); 
      } 
      catch(IOException ioEx) 
      { 
       ioEx.printStackTrace(); 
      } 

      input.close(); 
      output.close(); 
      client.close(); 
      System.out.println("\nClient closed.\n"); 
     } 
    } 
} 

ग्राहक:

package Networks.Nagle; 

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

public class NagleDemoClient 
{ 
    private static InetAddress host; 
    private static final int PORT = 1234; 

    public static void main(String[] args) 
    { 
     Socket socket = null; 

     try 
     { 
      host = InetAddress.getByName("localhost"); 

      socket = new Socket(host, PORT); 

      socket.setTcpNoDelay(true); 
      socket.setSendBufferSize(64); 

      System.out.println("Send Buffer: " + socket.getSendBufferSize()); 
      System.out.println("Timeout: " + socket.getSoTimeout()); 
      System.out.println("Nagle deactivated: " + socket.getTcpNoDelay()); 

     } 
     catch(UnknownHostException uhEx) 
     { 
      System.out.println("\nHost ID not found!\n"); 
      System.exit(1); 
     } 
     catch(SocketException sEx) 
     { 
      sEx.printStackTrace(); 
     } 
     catch(IOException ioEx) 
     { 
      ioEx.printStackTrace(); 
     } 

     NagleClientThread client = new NagleClientThread(socket); 
     NagleReceiverThread receiver = new NagleReceiverThread(socket); 

     client.start(); 
     receiver.start(); 

     try 
     { 
      client.join(); 
      receiver.join(); 

      socket.close(); 
     } 
     catch(InterruptedException iEx) 
     { 
      iEx.printStackTrace(); 
     } 
     catch(IOException ioEx) 
     { 
      ioEx.printStackTrace(); 
     } 

     System.out.println("\nClient finished."); 
    } 
} 


class NagleClientThread extends Thread 
{ 
    private Socket socket; 

    public NagleClientThread(Socket s) 
    { 
     socket = s; 

    } 

    public void run() 
    { 
     try 
     { 
      ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream()); 

      for(int i = 1; i < 1025; i++) 
      { 
       output.writeInt(i); 
       sleep(10); 
      } 

      output.flush(); 
      sleep(1000); 
      output.close(); 
     } 
     catch(IOException ioEx) 
     { 
      ioEx.printStackTrace(); 
     } 
     catch(InterruptedException iEx) 
     { 
      iEx.printStackTrace(); 
     } 
    } 
} 


class NagleReceiverThread extends Thread 
{ 
    private Socket socket; 

    public NagleReceiverThread(Socket s) 
    { 
     socket = s; 
    } 

    public void run() 
    { 
     String response = null; 
     BufferedReader input = null; 

     try 
     { 
      input = new BufferedReader(
         new InputStreamReader(socket.getInputStream())); 

      try 
      { 
       while(true) 
       { 
        response = input.readLine(); 
        System.out.print(response + " "); 
       } 
      } 
      catch(Exception e) 
      { 
       System.out.println("\nEnd of server data.\n"); 
      }  

      input.close(); 

     } 
     catch(IOException ioEx) 
     { 
      ioEx.printStackTrace(); 
     } 
    } 
} 

Answer 1

आप क्योंकि ReadLine अंतर (देखने के लिए सक्षम नहीं होगा) जब तक एक EOL पढ़ा जाता है इंतजार करेंगे। अंतर देखने के लिए, बाइनरी डेटा का उपयोग करें। 10ms नींद से अलग 64 बाइट्स के आउटगोइंग स्ट्रीम लिखने के ब्लॉक बनाएं। इनकमिंग स्ट्रीम को 1024 बाइट्स के ब्लॉक पढ़ें। जब tcpNoDelay सत्य है, आने वाली स्ट्रीम प्रत्येक पढ़ने के ऑपरेशन पर 64 बाइट्स को पढ़ा जाएगा। जब tcpNoDelay गलत है, आने वाली स्ट्रीम अधिक बाइट्स पढ़ेगी। आप प्रत्येक पठन ऑपरेशन में पढ़ने वाले बाइट्स की औसत संख्या लॉग कर सकते हैं, इसलिए अंतर स्पष्ट है। और हमेशा दो मशीनों का उपयोग करके परीक्षण करें, क्योंकि ओएस लूपबैक धाराओं को अनुकूलित कर सकता है।