关闭后Java客户端/服务器资源泄漏

Question

I am trying to implement a java command line chat server and client. I am using 4 classes, the Server.java sets up a ServerSocket and accepts all connections. The Client.java can connect to the Server, then 2 threads for both client and server are created using the SendMessages.java and ReceiveMessages.java. The threads are responsible for taking the input from stdin and sending it to the output stream of the socket, and taking the incoming input stream to print it to stdout. Everything works when launching the server and connecting the client, the chat also works. However, when either client or server is terminated a resource leak is caused. I want the SendMessages class and ReceiveMessages class to be able to detect when the connection of client or server is terminated and close all resources to avoid resource leaks. Here is the code:

Server.java

import java.net.*;
import java.io.*;
import java.util.*;
public class Server{
public static void main(String[] args) throws SocketException,IOException{
    ServerSocket s = new ServerSocket(8000);
    s.setSoTimeout(10000000);
    while(true){
        Socket clientSocket = s.accept();
    handle(clientSocket);

}  
}

   static void handle(Socket clientSocket) throws IOException{
    System.out.println("connection accepted from " + clientSocket.getRemoteSocketAddress());
    receiveMessages(clientSocket);
    sendMessages(clientSocket);
  }

  static void receiveMessages(Socket clientSocket) throws IOException{
    (new Thread(new ReceiveMessages(clientSocket))).start();;

  }

  static void sendMessages(Socket clientSocket)throws IOException{
    (new Thread(new SendMessages(clientSocket))).start();
  }
}

Client.java

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

public class Client{


public static void main(String[] args) throws IOException, UnknownHostException, ConnectException{
    String hostname = args[0];
    int port = Integer.parseInt(args[1]);
    Socket s = null;
    s = connect(hostname, port);
    handle(s);
}


public static Socket connect(String hostname, int port) throws UnknownHostException, IOException, ConnectException{
    Socket s = null;
    try{
    s = new Socket(hostname, port);
    } catch(ConnectException e){
        System.out.println("Connect Exception caught!");
    }
return s;
}

static void handle(Socket clientSocket) throws IOException, UnknownHostException{
receiveMessages(clientSocket);
sendMessages(clientSocket);
}

static void receiveMessages(Socket clientSocket) throws IOException, NullPointerException{
    (new Thread(new ReceiveMessages(clientSocket))).start();
  }

static void sendMessages(Socket clientSocket)throws IOException, NullPointerException{
  (new Thread(new SendMessages(clientSocket))).start();
}

}

SendMessages.java

import java.io.*;
import java.net.*;
import java.util.*;
public class SendMessages implements Runnable{
Socket clientSocket;

public SendMessages(Socket clientSocket){
    this.clientSocket = clientSocket;
}

public void run(){
    System.out.println("SendMessages thread has started.");
    Scanner sc = new Scanner(System.in);
    PrintWriter out = null;
    try{
    out = new PrintWriter(clientSocket.getOutputStream(), true);
    }
    catch(IOException | NullPointerException e){}

    String message;

    while(true){
        message = sc.nextLine();
        out.println(message);
        if(out.checkError()){
            out.close();
            sc.close();
            System.out.println("SendMessages closed");
        }
    }

}
}

ReceiveMessages.java

import java.io.*;
import java.net.*;
import java.util.*;
public class ReceiveMessages implements Runnable{
    Socket clientSocket;
    public ReceiveMessages(Socket clientSocket){
        this.clientSocket = clientSocket;
    }
    public void run(){
        System.out.println("ReceiveMessages thread has started.");
        BufferedReader in = null;
        try{
        in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        }catch(IOException|NullPointerException e){}
        String message;
        try{
            while(true){
            while((message = in.readLine())!= null){
                System.out.println(message);
            }

    }
    } catch(IOException|NullPointerException e){
        System.out.println("ReceiveMessages resources closed.");
        try{  
        in.close();
            clientSocket.close();
            }
            catch(IOException f){}
    }
}
}

Thank you!

Answer 1

So I have recently delt myself with such an issue.

The problem is, that by shutting one side of the connection down, a "half-open" connection remains (which isn't a real connection anymore).

The Socket API does not have an option to check, if the partnered service/device is still alive.

So what to do about that? I myself prefer the concept of heartbeats. Every 10 seconds (or any other timeframe, it's up to you) a heartbeat is send to the output stream of the socket. This operation throws a IOException, when the stream is no longer avaiable. Therefore you can catch the the exception and handle all "close" operations within the catch block.

Example:

    public class Heartbeater
    implements Runnable
{
  private OutputStream os;
  private ServerHandler servhand;
  private Logger logger = Logger.getLogger( Logger.GLOBAL_LOGGER_NAME );

  //NOTE: ServerHandler is my class which handles the socket of the server after ServerSocket.accept();
  public Heartbeater( OutputStream os, ServerHandler servhand )
  {
    this.servhand = servhand;
    this.os = os;
  }

  @Override
  public void run()
  {
    try
    {
      Thread.currentThread().setName( "Heartbeater" );
      // while the handler's connection is alive
      while ( servhand.isConnectionAlive() )
      {

        Thread.sleep( 10000 );

        // dummy write to trigger the exception if the client does not respond properly
        os.write( "_HEARTBEAT_".getBytes() );

      }
    }
    catch ( InterruptedException e )
    {
      logger.log( Level.SEVERE, "HEARTBEATER GOT INTERRUPTED", e );
      Thread.currentThread().interrupt();
    }
    catch ( IOException e )
    {
      logger.log( Level.INFO, "The connection to the client has been lost." );
      // Here you would define the resource close operation.
      servhand.setConnectionAlive( false );
    }
  }
}