package
             test;

            //
            : MultiJabberServer.java 

            //
            A server that uses multithreading to handle  

            //
            any number of clients. 
            import java.io.*; 
import java.net.*; 

class ServeOneJabber extends Thread { 
private Socket socket; 
private BufferedReader in; 
private PrintWriter out; 
public ServeOneJabber(Socket s)  
   throws IOException { 
 socket = s; 
 in =  
   new BufferedReader( 
     new InputStreamReader( 
       socket.getInputStream())); 
 // Enable auto-flush: 
 out =  
   new PrintWriter( 
     new BufferedWriter( 
       new OutputStreamWriter( 
         socket.getOutputStream())), true); 
 // If any of the above calls throw an  
 // exception, the caller is responsible for 
 // closing the socket. Otherwise the thread 
 // will close it. 
 start(); // Calls run() } 
publicvoid run() { 
 try { 
   while (true) {   
     String str = in.readLine(); 
     if (str.equals("END")) break; 
     System.out.println("Echoing: " + str); 
     out.println(str); 
   } 
   System.out.println("closing..."); 
 } catch (IOException e) { 
 } finally { 
   try { 
     socket.close(); 
   } catch(IOException e) {} 
 } 
} 
} 

publicclass MultiJabberServe {   
staticfinalint PORT = 5000; 
publicstaticvoid main(String[] args) 
   throws IOException { 
 ServerSocket s = new ServerSocket(PORT); 
 System.out.println("Server Started"); 
 try { 
   while(true) { 
     // Blocks until a connection occurs: 
     Socket socket = s.accept(); 
     try { 
       new ServeOneJabber(socket); 
     } catch(IOException e) { 
       // If it fails, close the socket, 
       // otherwise the thread will close it:        socket.close(); 
     } 
   } 
 } finally { 
   s.close(); 
 } 
}  

} ///:~ 

package test;
//: MultiJabberClient.java 
// Client that tests the MultiJabberServer 
// by starting up multiple clients. 
import java.net.*; 
import java.io.*; 
 
class JabberClientThread extends Thread { 
  private Socket socket; 
  private BufferedReader in; 
  private PrintWriter out; 
  private static int counter = 0; 
  private int id = counter++; 
  private static int threadcount = 0; 
  public static int threadCount() {  
    return threadcount;  
  } 
  public JabberClientThread(InetAddress addr) { 
    System.out.println("Making client " + id); 
    threadcount++; 
    try { 
      socket =  
        new Socket(addr, 5000); 
    } catch(IOException e) { 
      // If the creation of the socket fails,  
      // nothing needs to be cleaned up. 
    } 
    try {     
      in =  
        new BufferedReader( 
          new InputStreamReader( 
            socket.getInputStream())); 
      // Enable auto-flush: 
      out =  
        new PrintWriter( 
          new BufferedWriter( 
            new OutputStreamWriter( 
              socket.getOutputStream())), true); 
      start(); 
    } catch(IOException e) { 
      // The socket should be closed on any  
      // failures other than the socket  
      // constructor: 
      try { 
        socket.close(); 
      } catch(IOException e2) {} 
    } 
    // Otherwise the socket will be closed by 
    // the run() method of the thread. 
  } 
  public void run() { 
    try { 
      for(int i = 0; i < 25; i++) { 
        out.println("Client " + id + ": " + i); 
        String str = in.readLine(); 
        System.out.println(str); 
      } 
      out.println("END"); 
    } catch(IOException e) { 
    } finally { 
      // Always close it: 
      try { 
        socket.close(); 
      } catch(IOException e) {} 
      threadcount--; // Ending this thread 
    } 
  } 
} 
 
public class MultiJabberClient { 
  static final int MAX_THREADS = 40; 
  public static void main(String[] args)  
      throws IOException, InterruptedException { 
    InetAddress addr =  
      InetAddress.getByName("106.13.46.152"); 
    while(true) { 
      if(JabberClientThread.threadCount()  
         < MAX_THREADS) 
        new JabberClientThread(addr); 
      Thread.currentThread().sleep(100); 
    } 
  } 
} ///:~