o tópico no servidor irá parar e não tenho ideia do porquê

Normalmente, você cria um único ServerSockete um loop onde

• o servidor espera que um cliente se conecte
• um cliente se conecta
• crie sua classe cliente, passando a ela o socket que acabou de conectar
• servidor volta a esperar
• o cliente manipula o novo soquete io em um thread separado

Você tem dois threads e cada thread chama. socket = server.serverSocket.accept();Não tenho certeza de como isso funciona, mas não recomendo.

Modifiquei seu código com o mínimo de alterações possível para que você possa segui-lo:

import java.io.IOException;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server
{
    public static class ClientHandler implements Runnable
    {
        private Socket socket;
        private Thread thread;
        
        public ClientHandler(Socket socket) {
            this.socket = socket;
            thread = new Thread(this);
            thread.start();
        }

        @Override
        public void run() {
            try {
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                String msg;
                while ((msg = in.readLine()) != null) {
                    System.out.println(msg);
                    out.println(msg);
                }
            }
            catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    public static void main(String[] args)throws IOException {
        ServerSocket serverSocket = new ServerSocket(1234);
        while (true) {
            Socket socket = serverSocket.accept();
            ClientHandler clientHandler = new ClientHandler(socket);
        }
    }
}

Observação: isso permite que um número "infinito" de clientes se conectem. Se você quiser limitar a 2, precisará adicionar um pouco mais de lógica.

Conte onew .

Eu conto um único novo, o que significa que há apenas um manipulador. Isso significa que há apenas um campo Socket socket, apenas um campo ine assim por diante.

Quando você escreve isto:

List<String> list = new ArrayList<String>();

Costumamos dizer que "lista é um arraylist". Mas essa é uma simplificação perigosa. Perigosa porque é enganosa.

É mais preciso dizer que lista faz referência a uma arraylist. listÉ como um mapa do tesouro. São apenas instruções para chegar a uma instância de arraylist, não é a própria lista. new ArrayListFaz o tesouro, listé um mapa e =significa "desenhe a localização do tesouro no mapa".

Em Java, tudo é passado por valor, o que significa que, ao passar um parâmetro para um método, você está fazendo uma cópia. O que você está copiando, no entanto, é o mapa do tesouro .

Assim, quando você escreve:

List<String> list1 = new ArrayList<String>();
List<String> list2 = list1;

list1.add("Hello");
System.out.println(list2);

Isso imprimirá "olá". O operador ponto ( .) é javanês para "X marca o local, então vá lá, cave, abra o baú do tesouro, grite algo nele". list1.addAssim, pede ao próprio baú do tesouro para fazer algo (adicionar um valor neste caso), e quando você então caminha até o mesmo baú do tesouro usando uma cópia do mapa, você... acaba no mesmo tesouro.

Para realmente trazer isso para casa:

List<String> list = new ArrayList<String>();
doStuff();
System.out.println(list);

void doStuff(List<String> list) {
  list.add("Hello");
  list = List.of("Goodbye");
}

Isso imprimiria Hello. Não Goodbye. Porque list.addo doStuffmétodo vai até o tesouro e faz algo lá, enquanto list =não faz nenhuma escavação, ele simplesmente apaga o mapa do tesouro e desenha um novo X nele para uma lista recém-criada. list, a variável em si é uma cópia e, como todos os parâmetros e variáveis ​​locais, quando o método termina, essas variáveis ​​são descartadas. Então, a última linha desse método não faz nada - ele cria uma lista, atribui-a a uma variável e imediatamente joga a variável na lixeira. A lista permanece na areia, não há mapas restantes que possam encontrá-la. Eventualmente, o coletor de lixo virá e se livrará dela.

Tudo o que você realmente precisa fazer é substituir:

clientHandler clientHandler = new clientHandler();
Thread clienThread = new Thread(clientHandler);
Thread clienThread2 = new Thread(clientHandler);

Com:

Thread clienThread = new Thread(new clientHandler());
Thread clienThread2 = new Thread(new clientHandler());

Conte new: Agora existem 2x new, ou seja, 2 manipuladores de cliente, 2 soquetes, 2 leitores de buffer e assim por diante. Que é o que você quer.