Java: riconnessione su un socket a volte dà l'errore

Question

Sto facendo un client prototipo e server in modo che posso capire come gestire riconnette. Il server dovrebbe creare un ServerSocket e ascoltare per sempre. Un client può connettersi, inviare i suoi dati, e chiudere la sua presa, ma non invierà un messaggio "ho finito e la chiusura" tipo al server. Per questo motivo, il server riceve una EOFException quando lo fa un readByte() dal momento che il client remoto ha chiuso. Nel gestore di errore per il SocketWriteError, chiuderà la presa ed aprire uno nuovo.

Ecco il problema: Il client a volte diventa un outputStream.write() quando lo fa il <=> chiamano anche dopo che si apre con successo la presa / InputStream / outpustream. Essa può avere qualcosa a che fare con la frequenza che sto aprendo e chiudendo queste prese. Una cosa interessante è che il cliente fa un numero arbitrario di scritture / chiusura / ricollega prima crapping fuori. E a volte merda sulla prima riconnessione, altre volte ci vorranno 50 riconnette prima di vedere il <=>.

Ecco l'errore sul lato client:

java.net.SocketException: Connection reset by peer: socket write error
       at java.net.SocketOutputStream.socketWrite0(Native Method)
       at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:92)
       at java.net.SocketOutputStream.write(SocketOutputStream.java:115)
       at bytebuffertest.Client.main(Client.java:37)

Ecco alcuni frammenti di codice:

SERVER:

public static void main(String[] args)
{
    Server x = new Server();
    x.initialize();
}

private void initialize()
{
    ServerSocket s;
    InputStream is;
    DataInputStream dis;
    while (true) //ADDED THIS!!!!!!!!!!!!!!!!!!!!!!
    {
        try
        {
            s = new ServerSocket(4448);
            s.setSoTimeout(0);
            s.setReuseAddress(true);
            is = s.accept().getInputStream();
            System.out.println("accepted client");
            dis = new DataInputStream(is);
            try
            {

                byte input = dis.readByte();
                System.out.println("read: " + input);
            } catch (Exception ex)
            {
                System.out.println("Exception");
                dis.close();
                is.close();
                s.close();
            }
        } catch (IOException ex)
        {
            System.out.println("ioexception");
        }
    }
}

CLIENTE:

public static void main(String[] args)
{
    Socket s;
    OutputStream os;
    try
    {
        s = new Socket("localhost", 4448);
        s.setKeepAlive(true);
        s.setReuseAddress(true);
        os = s.getOutputStream();
        int counter = 0;
        while (true)
        {
            try
            {
                os.write((byte) counter++);
                os.flush();

                os.close();
                s.close();

                s = new Socket("localhost", 4448);
                s.setKeepAlive(true);
                s.setReuseAddress(true);
                os = s.getOutputStream();
            } catch (Exception e)
            {
                e.printStackTrace();
                System.err.println("ERROR: reconnecting...");
            }
        }
    } catch (Exception ex)
    {
        ex.printStackTrace();
        System.err.println("ERROR: could not connect");
    }
}

Qualcuno sa come per ricollegare correttamente?

Answer 1

Non chiudere il ServerSocket su un errore, basta Accetti () una nuova connessione.

Quello che faccio di solito è di volta in volta serversocket.accept () restituisce un socket, che depongono le uova fuori un thread per gestire l'invio e la ricezione di da quella Socket. In questo modo si è pronti per iniziare ad accettare una nuova connessione non appena qualcuno vuole connettersi a te.