Threading Chat in Command Prompt

[Joel Larson]

I'm just working with some basic socketing right now. So I made this chat client and server. Problem is you have to take turns typing messages back and forth. I am pretty new to java and I'm not too good with threads. What I want to know how to do is put the Recieving part and the Sending part in seperate threads so that it checks on both of them so that you don't have to take turns. Unless there is a better practice for something like this of course. After a few attempts I had to break down and ask other people. All I ask is a little guidance, I'm not asking anybody to write the script for me.
Client:

import java.io.*; 
import java.net.*; 
import javax.swing.*; 
 
public class chatClient {
  public static void main(String args[]) {
    String name = JOptionPane.showInputDialog("Enter Name"); 
 
    try {
   
      Socket s = new Socket("208.38.91.213", 8189);
      BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream())); 
      PrintWriter out = new PrintWriter(s.getOutputStream(), true);
      String message="";
      while (message != "exit") {
        message = JOptionPane.showInputDialog("Enter Message");
        System.out.println(name+": "+message);
 
        out.println(name+": "+message);
        String input = in.readLine();
        System.out.println(input);
      }
 
    } 
  catch(IOException e) { System.out.print("Some error occured... the server probably isnt up"); }
 
  System.exit(0);
  }
}

Server:

import java.io.*; 
import java.net.*;
import javax.swing.*; 
 
public class chatServer { 
  public static void main(String args[]) { 
    try { 
      ServerSocket s = new ServerSocket(8189); 
      Socket incoming = s.accept();
 
      BufferedReader in = new BufferedReader(new InputStreamReader(incoming.getInputStream()));
 
      PrintWriter out = new PrintWriter(incoming.getOutputStream(), true);
      String message=""; 
      while(message!="exit") {
        String input = in.readLine();
        System.out.println(input);
        message = JOptionPane.showInputDialog("Enter Message");
 
        System.out.println("Server: "+message);
        out.println("Server: "+message);
      }
      incoming.close();
    }
      catch(Exception e) { }
   
      System.exit(0);
  }
 
} 

[ July 04, 2003: Message edited by: Joel Larson ]

[Joel Larson]

Message here was editted in to original message.
[ July 04, 2003: Message edited by: Joel Larson ]

[Stan James]

I think this is typical of socket servers staring a new thread for each new client:

  
package com.saxman.cmdserver;
import java.io.IOException;
import java.net.Socket;
import java.net.ServerSocket;
/**
 * CmdServer listens on a port, starts a ServiceThread for each client that connects.
 * Command line arguments: [port]
 */
public class CmdServer
{
   private int mPort  = 4444;
   private ServerSocket mServerSocket;
   public CmdServer(String[] args) throws Exception
   {
      configure( args );
   }
   private void execute( )
   {
      try
      {
         startListening();
         acceptConnections();
      }
      catch (Exception e)
      {
         System.out.println( "CmdServer.execute Exception: " + e );
         e.printStackTrace();
      }
   }
   private void configure( String[] args )
   throws Exception
   {
      if ( args.length > 0 ) mPort = Integer.parseInt( args[0] );
      System.out.println("CmdServer.configure Port=" + mPort );
   }
   private void startListening()
   throws IOException
   {
      mServerSocket = new ServerSocket(mPort);
      System.out.println("CmdServer.execute Listening on mPort " + mPort );
   }
   private void acceptConnections()
   throws IOException
   {
      while( true )
      {
         Socket        lSocket   = mServerSocket.accept();
         ServiceThread lServicer = new ServiceThread( lSocket );
         new Thread(lServicer).start();
      }
   }
   /**
    * Command line arguments: [port]
    */
   public static void main( String[] args )
   {
      System.out.println("CmdServer.main");
      try
      {
         new CmdServer( args ).execute(  );
      }
      catch( Exception e )
      {
         System.out.println("CmdServer.main: Exception " + e );
      }
   }
}

My client also spins a thread to handle responses from the server.

package com.saxman.cmdserver;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
/**
 * Reads a line at a time from an input stream on its own thread. This can be used
 * to handle asynchronous input. For example, you might send a command to a socket
 * server that sends back several progress reports over the next few minutes.
 * <p>
 * The thread stops when the input line is null or equals the HaltCondition.
 * <p>
 * Override processLine to do something with the incoming data. Override processError
 * to do something useful on error.
 */
public class StreamReader extends Thread
{
   protected BufferedReader mReader;
   protected String mName;
   protected String mHaltCondition = null;
   /**
    * Constructor.
    * @param InputStream aStream - what we read
    * @param String aName - an identifier used in messages
    */
   StreamReader( InputStream aStream, String aName )
   {
      mReader = new BufferedReader( new InputStreamReader(aStream) );
      mName   = aName;
   }
   public void run()
   {
      try
      {
         String lLine = null;
         while ( ( lLine = mReader.readLine() ) != null )
         {
            if ( null != mHaltCondition )
               if ( lLine.equals( mHaltCondition ) )
                  break;
            processLine( lLine );
         }
      }
      catch (IOException e)
      {
         processError( e );
      }
   }
   /** Default implementation displays the line and continues. */
   protected void processLine( String aLine )
   throws IOException
   {
      System.out.println( mName + ": Line=" + aLine );
   }
   /** Default implementation displays the error and continues. */
   protected void processError( Exception e )
   {
      System.out.println( this.getClass().getName() + " " + mName + " Exception " + e );
   }
   public void   setHaltCondition( String aHaltCondition ) { mHaltCondition = aHaltCondition; }
   public String getHaltCondition() { return mHaltCondition; }
}

This whole program is here. It's not a chat thing, but some of the socket client and server ideas may work for you. Oh, and it's not bug free, either! Something is not right in what it does after handling a command.

[Jim Yingst]

You may also want to check out the example at
http://java.sun.com/docs/books/tutorial/networking/sockets/index.html

In particular, see the last two listings, for KKMultiServer and KKMultiServerThread.
I think this is typical of socket servers staring a new thread for each new client:
This is the standard technique for handling multiple clients concurrently. As of JDK 1.4 it's also possible to use a Selector for improved efficciency. If you have a lot of sockets where most are not really active at any one time, then you can have a single thread listen to all of them using a Selector. And whenever something of interest happens on one of the sockets, use another thread (probably obtained from a thread pool) to service that socket. The idea is to avoid having a bunch of threads sitting around waiting for something to happen, taking up resources. Instead have a smaller number of threads, that are actually doing something. This sort of design may not be necessary for a small server (especially if it's your first one), but it's worth remembering that other options exist.

[Joel Larson]

Wow, thanks alot. Those resources really help.