[Resolvido] Problema com o exemplo de chat do livro do Deitel

package chat;

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.InterruptedIOException;
    import java.net.Socket;
    import java.util.StringTokenizer;

    // Thread que espera mensagens de um cliente 
    // particular e envia mensagens para um MessageListener;
    // espera novas mensagens de clientes do MessengerServer em Threads separadas
    public class ReceivingThread extends Thread implements SocketMessengerConstants{
	
            private BufferedReader input;
	    private MessageListener messageListener;
	    private boolean keepListening = true;
	
	    // construtor
	    public ReceivingThread(MessageListener listener, Socket socketCliente) {
		
		    // invoca o construtor da super classe para dar nome à Thread
		    super("ReceivingThread: " + socketCliente);
		
		    // configura o ouvinte para o qual a novas mensagens devem ser enviadas
		    messageListener = listener;
		
		    // configura o tempo máximo de espera para leitura do socketCliente
		    // e cria um BufferedReader para ler as mensagens que chegam
		    try {
			    socketCliente.setSoTimeout(30000);
			
			    input = new BufferedReader(new InputStreamReader(socketCliente.getInputStream()));
			
		    } catch (IOException e) {
			
			    e.printStackTrace();
		    }
	    }
	
	    // espera novas mensagens e as envia ao MessageListener
	    public void run(){
		
		    String message;
		
		    // espera novas mensagens até que seja parado
		    while (keepListening){
			
			    // lê mensagem do BufferedReader
			    try{
				    message = input.readLine();
			
				    // trata exceção quando o tempo máximo para leitura é esgotado
			    }catch (InterruptedIOException interruptedIOException){				
				    continue;
			
			    }catch (IOException e){
				    e.printStackTrace();
				    break;
			    }
			
			    // assegura que a mensagem não está vazia
			    if(message != null){
				
				    // separa a mensagem em tokens para recuperar 
				    //o nome do usuário e o corpo da mensagem
				    StringTokenizer stringTokenizer = new StringTokenizer(message, MESSAGE_SEPARATOR);
				
				    // ignora mensagens que não têm um nome de usuário e um corpo de mensagem
				    if(stringTokenizer.countTokens() == 2){
					
					    // envia mensagem para o MessageListener
					    messageListener.messageReceived(
							    stringTokenizer.nextToken(),   // nome do usuario
							    stringTokenizer.nextToken()); // corpo da mensagem
				    }
				    else 
					
					    // se recebeu mensagem de desconexão, para de esperar mensagens
					    if(message.equalsIgnoreCase(MESSAGE_SEPARATOR + DISCONNECT_STRING)){
						    stopListening();
					    }
			    }
			
		    }
		
		    // fecha o BufferedReader (também fecha o socket)
		    try{
			    input.close();
		    }catch (IOException e){
			    e.printStackTrace();
		    }
	    }

	    // para de esperar por mensagens
	    public void stopListening(){
		    keepListening = false;
	    }
    }

package chat;

    import java.io.IOException;
    import java.io.InterruptedIOException;
    import java.net.DatagramPacket;
    import java.net.InetAddress;
    import java.net.MulticastSocket;
    import java.util.StringTokenizer;

    public class PacketReceivingThread extends Thread implements SocketMessengerConstants{

	    // MessageListener ao qual as mensagens devem ser entregues
	    private MessageListener messageListener;
	
	    // Multicatsocket para receber as mensagens transmitidas
	    private MulticastSocket multicastSocket;
	
	    // InetAddress do grupo de mensagens
	    private InetAddress multicastGrupo;
	
	    // indicador para terminar a PacketReceivingThread
	    private boolean keepListening = true;
	
	    // construtor
	    public PacketReceivingThread(MessageListener listener) {
		
		    super("PacketReceivingThread");
		
		    messageListener = listener;
	
		    // conecta o MulticastSocket ao endereco e a porta de multicast
		    try{
			    multicastSocket = new MulticastSocket(MULTICAST_LISTENING_PORT);
			
			    multicastGrupo = InetAddress.getByName(MULTICAST_ADDRESS);
			
			    // junta-se ao grupo de multicast para receber mensagens
			    multicastSocket.joinGroup(multicastGrupo);
			
			    // ajusta tempo máximo de 5 segundos para esperar novos pacotes
			    multicastSocket.setSoTimeout(20000);
		
		    }catch (IOException e) {
			    e.printStackTrace();
		    }
	    }
	
	    // espera as mensagens do grupo de multicast
	    public void run(){
		
		    // espera as mensagens até ser parada
		    while(keepListening){
			
			    // cria buffer para mensagens que chegam
			    byte[] buffer = new byte[MESSAGE_SIZE];
		
			    // cria DatagramPacket para mensagen que chega
			    DatagramPacket datagramPacket = new DatagramPacket(buffer, MESSAGE_SIZE);
			
			    // recebe novo DatagramPacket (chamada bloqueante)
			    try{
				    multicastSocket.receive(datagramPacket);
			
			    }catch (InterruptedIOException interruptedIOException){
				    interruptedIOException.printStackTrace();
			
			    }catch (IOException e){
				    e.printStackTrace();
				    break;
			    }
			
			    // coloca dados da mensagem em uma String
			    String message = new String(datagramPacket.getData());
			
			    // assegura que a mensagem não está vazia
			    if(message != null){
				
				    // elimina espaço em branco extra no fim da mensagem
				    message = message.trim();
				
				    // separa a mensagem em tokens para separar nome do usuario do corpo da mensagem
				    StringTokenizer stringTokenizer = new StringTokenizer(message, MESSAGE_SEPARATOR);
				
				    // ignora mensagens que não têm nome de usuario e corpo
				    if(stringTokenizer.countTokens() == 2){
					
					    // envia a mensagem para o MessageListener
					    messageListener.messageReceived(stringTokenizer.nextToken(), stringTokenizer.nextToken());
				    }
			    }
			
			    // sai do grupo de multicast e fecha o MulticastSocket
			    try{
				    multicastSocket.leaveGroup(multicastGrupo);
				    multicastSocket.close();
			
			    }catch (IOException e){
				    e.printStackTrace();
			    }
		    }
		
	    }
	
	    // para de esperar por novas mensagens
	    public void stopListening(){
		    keepListening = false;
	    }

    }

message = input.readLine();