并发线程读取套接字

Question

I have a simple Server-Client socket connection. I encapsulate all my data in objects which are sent backward and forward between the sockets, sent through ObjectStreams.

I have created a "HeartBeat" monitor, which runs in a separate thread, where both the server and the client, every 500ms, send a HeartBeat (empty object) backward and forward to check for connectivity, which works great. However, because of this, when I want to send other data between the server and client, it is mixed up with these HeartBeat objects.

For example my Server is expecting a Login object, but instead gets an object of instance HeartBeat.

My code is a simple client/server setup, so I don't think it'd be necessary to post their code, however, the HeartBeat code is as follows:

private static final int HEARTBEAT_INTERVAL = 500;

private void addHeartBeatMonitor(final Socket socket) {
    this.heartBeatTimer = new Timer();
    this.heartBeatTimer.scheduleAtFixedRate(new TimerTask() {
        @Override
        public void run() {
            try {
                ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());
                os.writeObject(new HeartBeat());
                ObjectInputStream is = new ObjectInputStream(socket.getInputStream());
                if (!(is.readObject() instanceof HeartBeat)) { throw new IOException(); }
            } catch (IOException e) {
                LOG.info("Received disconnect from " + getClientSocket().getInetAddress());
                heartBeatTimer.cancel();
                if (clientSocket != null) {
                    try {
                        clientSocket.close();
                    } catch (IOException e1) {}
                }
            } catch (ClassNotFoundException e) {}
        }
    }, 0, HEARTBEAT_INTERVAL);
}

My options seem to be to as follows:

1. Ditch the HeartBeat functionality, although there seems to be no other reliable way to check the connection status.
2. Find some other kind of Socket implementation which will magically fix all of this for me.
3. Have a synchronized method which oversees all reads and writes to the socket, which discards HeartBeats and sends other objects where they're meant to be.
4. Some kind of synchronization magic.

Thanks in advance for any help!

EDIT: Code which reads the Login object (server side):

User result = null;
try {
    ObjectInputStream is = new ObjectInputStream(this.getInputStream());
    Login request = (Login) is.readObject(); ### ERROR ###
    result = this.mongoService.login(request);
    ObjectOutputStream os = new ObjectOutputStream(this.getOutputStream());
    os.writeObject(result);
} catch (IOException e) {
} catch (ClassNotFoundException e) {}
return result;

Exception as follows:

Exception in thread "Thread-0" java.lang.ClassCastException: model.HeartBeat cannot be cast to model.Login
    at socket.SocketServerWorker.login(SocketServerWorker.java:78)
    at socket.SocketServerWorker.<init>(SocketServerWorker.java:47)
    at socket.SocketServer$2.run(SocketServer.java:50)
    at java.lang.Thread.run(Thread.java:744)

Answer 1

Consider doing something like this. I just threw this together, so it's obviously untested, but I'm sure you'll get the idea:

public class HeartBeatMonitor
{
    final Map<Class,Consumer> handlers = new HashMap<> ();
    final Socket sock;
    final ObjectInputStream is;
    final ObjectOutputStream os;

    public HeartBeatMonitor (final Socket sock)
    {
        try
        {
            this.sock = sock;
            this.is = new ObjectInputStream (sock.getInputStream ());
            this.os = new ObjectOutputStream (sock.getOutputStream ());
        }
        catch (final IOException e)
        {
            throw new RuntimeException (e);
        }
    }

    public <T> void setHandler (final Class<T> type, final Consumer<? super T> handler)
    {
        this.handlers.put (type, handler);
    }

    // This would be called in a loop
    void accept () throws ClassNotFoundException, IOException
    {
        final Object o = this.is.readObject ();
        final Consumer handler = this.handlers.get (o.getClass ());
        if (handler != null)
            handler.accept (o);
        // Else default handler?
    }
}