Endless loop condition

Question

Hi there,
Working on a client/server chat application. On the client side app, everytime I want to send a message I create a new Thread called "SendingThread". See below.
import java.io.*;
import java.net.*;
public class SendingThread extends Thread
  private Socket clientSocket;
  private String messageToSend;
  public SendingThread(Socket socket, String userName, String message)
       super("SendingThread: " + socket);
       clientSocket = socket;
       messageToSend = userName + Constants.MESSAGE_SEPERATOR + message;
  public void run()
       try
            PrintWriter writer = new PrintWriter(clientSocket.getOutputStream());
            writer.println(messageToSend);
            writer.flush();
            writer.close();
       catch(IOException ioe)
            System.out.println("Server must have closed connection");
            ioe.printStackTrace();
}As you can see the line writer.close() is important in regard to a Thread that is running on the server app called "ReceivingThread" (see below). In the ReceivingThread there is a line:
if((temp = input.readLine()) != null)
It blocks until I actually send a message to read in. This is expected. However, now I have a catch 22 situation. On the client side app, since I called writer.close(), this was necessary in order to get a null value during the readLine() call on the ReceivingThread on the server. The one line gets processed as expected. The stream is now closed and on the server side app, since this is true, the next iteration of the while loop attempts to read in another line but now it is alway null and thus I wind up with an endless loop condition. I introduced a "count" variable and a condition only so that the loop wouldn't get away too far. I was hoping it would block again, but it isn't. I believe the ReceivingThread is written correctly, but I need to somehow obtain a null value on the stream for message completion and also have the ReceivingThread block for the next message coming in.
Please advise,
Alan
public class ReceivingThread extends Thread
  private BufferedReader input;
  private MessageListener messageListener;
  private boolean keepListening = true;
  public ReceivingThread(MessageListener listener, Socket clientSocket)
       super("ReceivingThread: " + clientSocket);
       messageListener = listener;
       try
            clientSocket.setSoTimeout(50000);
            input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
       catch(IOException ioe){ioe.printStackTrace();}
  public void run()
       StringBuffer messageBuffer = new StringBuffer();
       String temp = "";
       int messageCount = 0;
       int count = 0;
         //START:
         while(keepListening)
           while(true)
              try
                //In order to receive a null, the client app
                //has to close the stream!  Otherwise, this
                //will block indefinitely.
                System.out.println("blocking...");
                if((temp = input.readLine()) != null)
                   if(messageCount == 0)
                        messageBuffer.append(temp);
                        messageCount++;
                        System.out.println("temp: " + temp);
                   else
                     //When we use the readLine method, it strips
                     //off the newline character, so we need to
                     //put it back.
                     messageBuffer.append("\n" + temp);
                     System.out.println("temp: " + temp);
                else
                     break;
              catch(IOException ioe)
                   System.out.println("IOException...");
                   ioe.printStackTrace();
                   //break;
           }//end while
            //System.out.println("out of inner while loop...message:\n" + messageBuffer.toString());
            String message = messageBuffer.toString();
            System.out.println("message: " + message);
            StringTokenizer tokenizer = new StringTokenizer(message, Constants.MESSAGE_SEPERATOR);
            if(tokenizer.countTokens() == 2)
                 System.out.println("message received");
                 messageListener.messageReceived(tokenizer.nextToken(), tokenizer.nextToken());
                 //reset string variables
                 messageCount = 0;
                 temp = "";
                 messageBuffer.delete(0, messageBuffer.length());
                 message = "";
            else
                //System.out.println("checking disconnect string: " + message);
               if(message.equalsIgnoreCase(Constants.MESSAGE_SEPERATOR + Constants.DISCONNECT_STRING))
                      stopListening();
            count++;
            if(count > 3)break;
         }//end while
         try
           //System.out.println("closing ReceivingThread");
           input.close();        
         catch(IOException ioe){ioe.printStackTrace();}
  public void stopListening()
       keepListening = false;
}Edited by: ashiers on Nov 21, 2007 7:33 AM
Edited by: ashiers on Nov 21, 2007 7:34 AM

Answer 1

I'm not quite sure what you want to happen here. Here is what I would expect from the code you posted:
*1.* The client connects and sends its message to the server.
*2.* The server iterates through the line-reading loop until it exhausts the input (input.readLine() == null) and breaks out of the while (true) loop. The "temp: foo" messages are written to standard output accordingly.
*3.* The server reaches the message portion of the loop and writes the "message: foo" to standard output.
*4.* The server hits the end of the "while (keepListening)" loop and (assuming that you didn't receive a disconnect message) keepListening is still true. So it loops back around.
*5.* The first time through the while (true) loop, the input is still empty (of course). So you get a null.
*6.* Next, you get a "message: foo" output.
*7.* Repeat *4* through *6* until your computer hardware fails or you abort the program. (Except that you added that count thing, so it'll loop three times and then break.)
What are you trying to make the "keepListening" loop do? It doesn't seem like it should be there at all. At no point does this reading thread get the opportunity to read from any other socket. It almost seems like you want to spawn one ReceivingThread for each Socket you receive from the ServerSocket; if that's the case, the main thread (or whichever thread you have running that code and spawning the ReceivingThreads should be inside of the while (keepListening) loop.
Any help?