客户端-服务器双向通讯

Question

I wrote simple client serwer, but unfortunately, I did it so chaotic and poorly that I decided to write everything from scratch. I want to write to communicate in both directions with the ability to disconnect and connect a new client. It means the client or the server sends a message and an appropriate one reads it. At the beginning all works but when i want to close client i get two errors:

java.net.SocketException: Socket closed readSocketData()
java.net.SocketException: Socket closedwriteData(String data)

Of course I understand what those errors means , but I do not understand why they show up because i have a while loop in which i check if the client is connected. Later when i try to connect a new client everything is falling apart. I wrote 3 classes client, server and communication. Client and server inherits from communication (methods for opening and reading data streams). It all looks like that:

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server extends Communication{

ServerSocket serverSocket;
Socket listener;
boolean listenerLife;

public Server(int port) {

    try {
        serverSocket = new ServerSocket(port);
    } catch (IOException e) {
        System.out.println(e);
    }
}

public void startListener(){

    while (true){
        try {
            listener = serverSocket.accept();
            listenerLife = true;
        } catch (IOException e) {
            System.out.println(e);
        }
        openWriter(listener);
        openReader(listener);
        writeServerDataThread();
        new Thread(new Runnable() {
            @Override
            public void run() {
                readData();
            }
        }).start();
    }

}

public void writeServerDataThread(){
    openLocalReader();
    new Thread(new Runnable() {
        @Override
        public void run() {
            while (true){
                String data = readLocalData();
                writeData(data);
            }
        }
    }).start();
}


public void readData(){
    while (listenerLife){
        String data = readSocketData();

        if("exit".equals(data) || data == null){
            try {
                listenerLife = false;
                listener.close();
            } catch (IOException e) {
                System.out.println(e);
            }
        }
        else {
            System.out.println(data);
        }

    }
}



public void writeData(String data){
    try {
        writer.writeBytes(data + '\n');
        writer.flush();
    } catch (IOException e) {
        System.out.println(e);
    }
}



public static void main(String[] args) {
    Server server = new Server(8080);

    server.startListener();


}
}
import java.io.IOException;
import java.net.Socket;

public class Client extends Communication{

Socket clientSocket;
boolean clientLive;

public Client(String hostName, int port) {

    try {
        clientSocket = new Socket(hostName, port);
        clientLive = true;
    } catch (IOException e) {
        System.out.println(e + "Client(String hostName, int port)");
    }

}

public boolean closeConnection(String data){
    if("exit".equals(data) || data == null){
        try {
            writeData("Zamykam klienta");
            clientSocket.close();
            clientLive = false;
            return false;
        } catch (IOException e) {
            System.out.println(e + "closeConnection(String data)");
        }
    }
    return true;
}

public void readClientData(){
    new Thread(new Runnable() {
        @Override
        public synchronized void run() {
            openLocalReader();
            while (!clientSocket.isClosed()){
                String data = readLocalData();

                if(closeConnection(data)){
                    writeData(data);
                }
            }
        }
    }).start();

}

public void readServerDataThread(){
    new Thread(new Runnable() {
        @Override
        public synchronized void run() {
            while (!clientSocket.isClosed()){
                String data = readSocketData();

                if(closeConnection(data)){
                    System.out.println(data);
                }
            }
        }
    }).start();

}

public void writeData(String data){
    try {
        writer.writeBytes(data + '\n');
        writer.flush();
    } catch (IOException e) {
        System.out.println(e + "writeData(String data)");
    }
}

public static void main(String[] args) {
    final Client client = new Client("localhost", 8080);
    client.openReader(client.clientSocket);
    client.openWriter(client.clientSocket);
    client.readServerDataThread();

    client.readClientData();


}
}
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

public class Communication {

BufferedReader reader;
BufferedReader localReader;
DataOutputStream writer;

public void openReader(Socket incomingSocket){

    try {
        reader = new BufferedReader(new   InputStreamReader(incomingSocket.getInputStream()));
    } catch (IOException e) {
        System.out.println(e);
    }
}

public void openWriter(Socket incomingSocket){

    try {
        writer = new DataOutputStream(incomingSocket.getOutputStream());
    } catch (IOException e) {
        System.out.println(e);
    }
}

public void openLocalReader(){
    localReader = new BufferedReader(new InputStreamReader(System.in));
}

public String readLocalData(){
    String data = null;

    try {
        data = localReader.readLine();
    } catch (IOException e) {
        System.out.println(e + " readLocalData()");
    }
    return data;
}

public String readSocketData(){
    String data = null;

    try {
        data = reader.readLine();
    } catch (IOException e) {
        System.out.println(e + " readSocketData()");
    }
    return data;
}

}

Answer 1

java.net.SocketException: Socket closed readSocketData()
java.net.SocketException: Socket closed writeData(String data)

Of course I understand what those errors means

They mean you closed the socket and continued to use it.

but I do not understand why they show up because i have a while loop in which i check if the client is connected.

No you don't. You have a while loop in which you check if the client socket is still open, which isn't the same thing at all ... but in any case that doesn't prevent you from using a closed socket inside the loop, for example after you close it in closeConnection() , whose return value being back to front from what it should be is doubtless causing confusion, and which is called by two threads as far as I can tell.