Java Socketing: мой серверный класс постоянно принимает ввод, а мой клиент — нет?

Потоки не могут быть повторно упакованы. После назначения оболочки они должны использовать эту оболочку на протяжении всего жизненного цикла потока. Вы также не должны закрывать поток, пока не закончите его использование, что в данном случае не произойдет, пока ваш клиент и сервер не закончат общение.

В вашем текущем коде несколько раз вы повторно инициализируете потоки:

while (true) {
    try {
        //Each loop, this reader will attempt to re-wrap the input stream
        BufferedReader br = new BufferedReader(new InputStreamReader(skt.getInputStream()));

        String incomingMessage = br.readLine();
        if (incomingMessage != null) {
            System.out.println("Server: Received message: " + incomingMessage);
            processMessage(incomingMessage);
        }

        //don't close your stream and socket so early!
        br.close();
        skt.close();
    } catch (Exception e) {
        //...
    }

Вы поняли идею; вы можете использовать эти знания, чтобы найти проблемы с потоком в вашем клиентском коде.

При этом серверы являются посредниками между несколькими клиентами. Если вы хотите иметь возможность печатать в консоли сервера для отправки сообщения клиентам, оно не должно направляться только одному клиенту (если только у вас нет системы, позволяющей указать имя). Вам нужно хранить каждое соединение в какой-то коллекции, поэтому, когда вы вводите консоль сервера, она переходит к каждому подключенному клиенту. Это также помогает, когда клиент хочет отправить сообщение каждому другому клиенту (глобальное сообщение). Основной поток сервера в первую очередь предназначен для приема клиентов; Я создал еще один поток, чтобы вы могли ввести консоль.

Что касается ваших потоков, вы должны создавать их всякий раз, когда запускаете ClientTask, как на стороне сервера, так и на стороне клиента:

public class Server {
    private ExecutorService executor = Executors.newFixedThreadPool(10);
    private Set<User> users = new HashSet<>();

    private boolean running;
    private int port;

    public Server(int port) {
        this.port = port;
    }

    public void start() {
        running = true;

        Runnable acceptor = () -> {
            try(ServerSocket ss = new ServerSocket(port)) {
                while(running) {
                     User client = new User(ss.accept());
                     users.add(client);
                     executor.execute(client);
                }
            } catch(IOException e) {
                //if a server is already running on this port;
                //if the port is not open;
                e.printStackTrace();
            }
        };

        Runnable userInputReader = () -> {
            try(Scanner scanner = new Scanner(System.in)) {
                while(running) {
                    String input = scanner.nextLine();

                    for(User user : users) {
                        user.send(input);
                    }
                }
            } catch(IOException e) {
                //problem sending data;
                e.printStackTrace();
            }

        };

        Thread acceptorThread = new Thread(acceptor);
        Thread userThread = new Thread(userInputReader);
        acceptorThread.start();
        userThread.start();
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        new Server(15180).start();
        System.out.println("Server started!");
    }
}

В методе run() потоки должны быть обернуты.

class User implements Runnable {
    private Socket socket;
    private boolean connected;

    private DataOutputStream out; //so we can access from the #send(String) method

    public User(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        connected = true;

        try(DataInputStream in = new DataInputStream(socket.getInputStream())) {
            out = new DataOutputStream(socket.getOutputStream());

             while(connected) {
                 String data = in.readUTF();
                 System.out.println("From client: "+data);
                 //send to all clients
             }
         } catch(IOException e) {
             //if there's a problem initializing streams;
             //if socket closes while attempting to read from it;
             e.printStackTrace();
         }
    }

    public void send(String message) throws IOException {
        if(connected) {
            out.writeUTF(message);
            out.flush();
        }
    }
}

Это почти та же идея с клиентом: 1. Подключиться к серверу 2. Создать поток «связи» 3. Создать поток «пользовательский ввод» (для получения ввода с консоли) 4. Запустить потоки

public class Client {
    private final String host;
    private final int port;

    private boolean connected;
    private Socket socket;

    public Client(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws IOException {
        connected = true;
        socket = new Socket(host, port);

        Runnable serverInputReader = () -> {
            try (DataInputStream in = new DataInputStream(socket.getInputStream())) {
                while (connected) {
                    String data = in.readUTF();
                    System.out.println(data);
                }
            } catch (IOException e) {
                // problem connecting to server; problem wrapping stream; problem receiving data from server;
                e.printStackTrace();
            }
        };

        Runnable userInputReader = () -> {
            try (DataOutputStream out = new DataOutputStream(socket.getOutputStream());
                    Scanner scanner = new Scanner(System.in)) {
                while (connected) {
                    String input = scanner.nextLine();
                    out.writeUTF(input);
                }
            } catch (IOException e) {
                //problem wrapping stream; problem sending data;
                e.printStackTrace();
            }
        };

        Thread communicateThread = new Thread(serverInputReader);
        Thread userThread = new Thread(userInputReader);
        communicateThread.start();
        userThread.start();
    }

    public static void main(String[] args) throws IOException {
        new Client("localhost", 15180).start();
    }
}

Есть несколько вещей, которые я использовал в приведенном выше коде, с которыми вы, возможно, не знакомы. Они помогают упростить синтаксис вашего кода:

• лямбда-выражения – предотвращает необходимость создания анонимного класса (или подкласс) для объявления метода
• Try-With-Resources — автоматически закрывает указанные ресурсы после попробуйте заблокировать как завершенный

EDIT Когда пользователь подключается, вы должны сохранить его подключение по имени или идентификатору. Таким образом, вы можете отправлять данные конкретным пользователям. Даже если ваш клиент работает на том же компьютере, что и сервер, идея остается той же: клиент подключается к серверу, сервер отправляет сообщение клиенту на основе имени или идентификатора:

            while(running) {
                 User client = new User(ss.accept());
                 users.add(client); //add to set
                 executor.execute(client);
            }

Прямо сейчас вы просто добавляете пользователей в файл Set. В настоящее время нет способа получить конкретное значение из этого набора. Что вам нужно сделать, так это дать ему какой-то «ключ». Чтобы дать вам представление, вот старый алгоритм, который я использовал. У меня есть массив, полный пустых слотов. Когда кто-то подключается, я ищу первый свободный слот. Как только пустой слот найден, я передаю пользователю индекс массива, в котором он хранится (это будет идентификатор пользователя), а затем сохраняю пользователя в массиве по указанному индексу. Когда вам нужно отправить кому-то сообщение, вы можете использовать идентификатор для доступа к этому конкретному индексу массива, захватить нужного пользователя и отправить сообщение:

class Server {
    private int maxConnections = 10;
    private ExecutorService executor = Executors.newFixedThreadPool(maxConnections);
    private User[] users = new User[maxConnections];

    //...

    while(running) {
        Socket socket = ss.accept();

        for(int i = 0; i < users.length; i++) {
            if(users[i] == null) {
                users[i] = new User(socket, i);
                executor.execute(users[i]);
                break;
            }
        }
    }

    //...

    public static void sendGlobalMessage(String message) throws IOException {
        for(User user : users)
            if(user != null)
                user.send(message);
    }

    public static void sendPrivateMessage(String message, int id) {
        User user = users[id];

        if(user != null) {
            user.send(message);
        }
    }
}

class User {
    private Socket socket;
    private int id;

    private DataOutputStream out;

    public User(Socket socket, int id) {
        this.socket = socket;
        this.id = id;
    }

    public void send(String message) throws IOException {
        out.writeUTF(message);
        out.flush();
    }

    public void run() {
        DataInputStream in;
        //wrap in and out streams

        while(connected) {
            String data = in.readUTF();

            //Server.sendGlobalMessage(data);
            //Server.sendPrivateMessage(data, ...);
            sendMessage(data); //sends message back to client
        }
    }
}