Socket connection dies after some time being idle w/o firing event

Question

Hi,
I use this code to connecto my server from my Client
          if (socket == null){
               try{
                    if (pwd.length > 0)
                         System.out.println("opening connection...to "+host+" at port "+port);
                         socket = new Socket(host, port);          
                         toServer = new ObjectOutputStream(socket.getOutputStream());
                         fromServer = new ObjectInputStream(socket.getInputStream());
                         System.out.println("Connection established!");
                         fireClientEvent(new ClientEvent(this, ClientEvent.CONNECTION_ESTABLISHED, ""));
                         this.connected = true;
                         Hashtable<String, String> table = new Hashtable<String, String>();
                         table.put("action", "login");
                         table.put("key", convertToString(pwd));
                         sendObject(table);
               }catch(IOException e){
                    try{
                         if (socket != null)
                              socket.close();
                         System.out.println("Error while connecting... Server does not exist!");
                         this.connected = false;                         
                         fireClientEvent(new ClientEvent(this, ClientEvent.SERVER_DOES_NOT_EXIST, getHost()+":"+getPort()));
                    }catch(IOException x){
                         System.out.println("I/O ERROR @ CLIENT CONNECT!");
                         removeAllListeners();
                         x.printStackTrace();
          }And this is how my server responds to client requests:
     public void run()
          ServerSocket server = null;
          Socket socket           = null;
          Hashtable<String, String> ClientInfo = new Hashtable<String, String>(); 
          try{
               server = new ServerSocket(getPort());
               //listen for connections
               while (!stopServer)
                    try{
                         System.out.println("Starting Server at port: "+getPort());
                         socket = server.accept();
                         ClientInfo.put("remoteip", socket.getInetAddress().toString());
                         fireServerEvent(new ServerEvent(ClientInfo, ServerEvent.CONNECTION_REQUESTED, null));
                         ThreadedSocket tsocket = getThreadedSocket(socket);
                         tsocket.addSocketListener(this);
                         tsocket.setMaxSolvingTime(maxSolvingTime);
                         Sockets.add(tsocket);
                         executor.execute(tsocket);
                         fireServerEvent(new ServerEvent(ClientInfo, ServerEvent.CONNECTION_ESTABLISHED, null));
                    }catch (IOException ioe){
                         fireServerEvent(new ServerEvent(ClientInfo, ServerEvent.UNEXPECTED_CONNECTION_ERROR, null));
                         exceptionThrown(ioe);
          }catch(Exception x){
               exceptionThrown(x);
          }finally{
               try{
                    server.close();
                    socket.close();
               }catch (Exception e){
                    exceptionThrown(e);
     }It seems that after some time (aprox. 10-15 minutes) being idle, my client gets disconnected withougt firing any event so the Server thinks the client is still connected but it does not get any messages because the client has closed the connection (I think)
Am I doing/thinking something wrong?

Answer 1

Thanks It seems that I am doing something completely wrong.
I created this object:
package main;
import java.util.Hashtable;
import java.util.Vector;
public class SocketPinger implements Runnable {
    private Vector<ThreadedSocket> sockets = null;
    Hashtable<String, Object> action = new Hashtable<String, Object>();
    public SocketPinger()
        action.put("action", "scheduled_ping");
    public SocketPinger(Vector<ThreadedSocket> socks)
        this.sockets = socks;
        action.put("action", "scheduled_ping");
    public void run()
         process();
    public void process()
         if (sockets != null)
              for (ThreadedSocket socket : this.sockets)
                   try
                        socket.sendObject(action);
                   }catch(Exception e){
                        sockets.remove(socket);
    public void setSockets(Vector<ThreadedSocket> socks)
         this.sockets = socks;
}which I call with this command:
     public class ThreadScheduler
         private SocketPinger pinger;
         private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
         public void activate()
             pinger = new SocketPinger(Sockets);
             scheduler.scheduleWithFixedDelay (pinger, 5, 10, TimeUnit.SECONDS);            
         public void deactivate() {
             scheduler.shutdown();
     }This makes the Scheduler object wake up every 10 secs and ping all the clients. This works and since then everything seemed to work fine. Today I noticed that when I shut down the client abnormaly (System.exit(0);) the server doesn't understand it. The sendObject() method works fine.
This is my ThreadedSocket with the sendObject() method:
public class ThreadedSocket extends Thread
     protected Socket socket;     
     protected ObjectOutputStream toClient;
     protected ObjectInputStream fromClient;
     protected ConnectionPool Pool;
     protected DBManager db;
     public ThreadedSocket(Socket sock, int priority, ConnectionPool pool) throws IOException
          socket = sock;
          this.Pool = pool;
          toClient = new ObjectOutputStream(socket.getOutputStream());
          fromClient = new ObjectInputStream(socket.getInputStream());                    
          setPriority(priority);     
          db = new DBManager(Pool);
     public void sendMessage(String message)
          try{
               toClient.writeUnshared(message);
               toClient.flush();
          }catch(Exception e){
     public void sendObject(Hashtable<String, Object> table)
          try{               
               toClient.writeUnshared(table);
               toClient.flush();
               toClient.reset();
          }catch(Exception e){
     }and this is how I initialize the ThreadedSocket on my Server object
     public void run()
          ServerSocket server = null;
          Socket socket           = null;
          Hashtable<String, String> ClientInfo = new Hashtable<String, String>(); 
          try{
               server = new ServerSocket(getPort());
               //listen for connections
               while (!stopServer)
                    try{
                         System.out.println("Starting Server at port: "+getPort());
                         socket = server.accept();
                         ClientInfo.put("remoteip", socket.getInetAddress().toString());
                         fireServerEvent(new ServerEvent(ClientInfo, ServerEvent.CONNECTION_REQUESTED, null));
                         ThreadedSocket tsocket = getThreadedSocket(socket);
                         tsocket.addSocketListener(this);
                         tsocket.setMaxSolvingTime(maxSolvingTime);
                         Sockets.add(tsocket);
                         executor.execute(tsocket);
                         fireServerEvent(new ServerEvent(ClientInfo, ServerEvent.CONNECTION_ESTABLISHED, null));
                    }catch (IOException ioe){
                         fireServerEvent(new ServerEvent(ClientInfo, ServerEvent.UNEXPECTED_CONNECTION_ERROR, null));
                         exceptionThrown(ioe);
          }catch(Exception x){
               exceptionThrown(x);
          }finally{
               try{
                    server.close();
                    socket.close();
                    if (scheduler != null)
                         scheduler.deactivate();
               }catch (Exception e){
                    exceptionThrown(e);
          So I have to make this question unanswered, because it is actually partially answered. Although the server can wake up and ping the clients, I still find it difficult to see if the client really exists after some abnormal termination (i.e. computer dies, or sth similar).