Java 套接字在发送消息后被神秘地从hashmap中删除

所以我对java套接字还不熟悉，并且刚刚开始使用它们。问题是：我有一个客户端和一个服务器应用程序。客户端希望向另一个客户端发送一些消息。这些消息将到达服务器，在服务器端，我将它们放入队列中，并每2秒检查一次目标客户机（套接字）是否处于活动状态。如果是这样，那么我将清空队列并将每条消息发送到特定的客户端。否则，消息将存储在服务器应用程序中，直到目标套接字处于活动状态

然而，主要的问题是，在服务器将第一条消息传递到套接字之后，客户端（目标）套接字就会消失。我尝试将这些套接字存储在hashmap中。因此，在发送第一条消息之后，hashmap不知何故变为空。我无法传达其余的信息

我提供了一些代码：

public class Server {
    
    public static volatile HashMap<Socket,String> clients;
    
    public Server(){
        clients = new HashMap<>();
    
    }
    
    
    public void start(){
        try(ServerSocket serverSocket = new ServerSocket(5000)){
            
            while(true){
            
                
                Socket socket = serverSocket.accept();
                System.out.println("Client connected");
                
                new clientHandler(socket).start();
                
            }
 
        
        }catch(IOException e){
            e.printStackTrace();
        }
            
    }
    
}

公共类服务器{
公共静态易失HashMap客户端；
公共服务器（）{
clients=newhashmap（）；
}
公开作废开始（）{
try（ServerSocket-ServerSocket=newserversocket（5000））{
while（true）{
Socket=serverSocket.accept（）；
System.out.println（“客户端连接”）；
新的clientHandler（socket.start（）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}

public类clientHandler扩展线程{
专用插座；
私有套接字sendSocket；
私人定时器；
专用队列msgStack；
私有字符串socketName=“”；
公用clientHandler（插座）{
this.socket=socket；
msgStack=new PriorityQueue（）；
}
@凌驾
公开募捐{
试一试{
BufferedReader输入=新的BufferedReader（新的InputStreamReader（socket.getInputStream（））；
PrintWriter输出=新的PrintWriter（socket.getOutputStream（），true）；
while（true）{
String line=input.readLine（）；
如果（！line.contains（“|”）&&line！=null）{
如果（！isclientaded（行））{
Server.clients.put（套接字、行）；
}
}否则{
系统输出打印项次（行）；
字符串[]msg=line.split（“\\\\”）；
字符串fromUser=msg[0]；
字符串toUser=msg[1]；
字符串主题=msg[2]；
字符串msgText=msg[3]；
如果（被许可（toUser））{
sendMsg（行）；
if（timer.isRunning（））{
timer.stop（）；
}
}否则{
msgStack.add（行）；
计时器=新计时器（2000，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
System.out.println（msgStack+“”+msgStack.size（））；
如果（被许可（toUser））{
如果（！msgStack.isEmpty（））{
sendMsg（msgStack.poll（））；
System.out.println（“消息：“+fromUser+”“+toUser+”“+subject+”“+msgText”）；
}
if（msgStack.isEmpty（））{
timer.stop（）；
}
}
}
});
timer.start（）；
}
}
}
}捕获（SocketException例外）{
例如printStackTrace（）；
删除（套接字）；
}捕获（IOEX异常）{
例如printStackTrace（）；
}
}
公共布尔值IsClient（字符串clientName）{
迭代器it=Server.clients.entrySet（）.Iterator（）；
while（it.hasNext（））{
Map.Entry对=（Map.Entry）it.next（）；
if（clientName.equals（pair.getValue（）+））{
返回true；
}
it.remove（）；
}
返回false；
}
公共void sendMsg（字符串发送）{
字符串[]msg=send.split（“\\\\”）；
字符串fromUser=msg[0]；
字符串toUser=msg[1]；
字符串主题=msg[2]；
字符串msgText=msg[3]；
迭代器it=Server.clients.entrySet（）.Iterator（）；
while（it.hasNext（））{
Map.Entry对=（Map.Entry）it.next（）；
if（（pair.getValue（）+）.equals（toUser））{
试一试{
套接字=（（套接字）对.getKey（））；
PrintWriter输出=新的PrintWriter（socket.getOutputStream（），true）；
println（fromUser+“|”+subject+“|”+msg）；
}捕获（IOEX异常）{
例如printStackTrace（）；
}
}
it.remove（）；
}
}
}

---

我根据每一个套接字的对“name”来识别它们。这就是我知道应该发送消息的套接字的方式。

是的，多亏了上面评论部分的Rocco，我解决了这个问题。问题出在it.remove（）部分。我从另一个项目复制/粘贴了这个hashmap迭代代码，因为

public class clientHandler extends Thread{
    
    private Socket socket;
    private Socket sendSocket;
    private Timer timer;
    private Queue<String> msgStack;
    private String socketName = "";
    
    
    public clientHandler(Socket socket){
        this.socket = socket;
        msgStack = new PriorityQueue<>();
    }
    
    
    
    @Override
    public void run(){
        try {
            BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            
            PrintWriter output = new PrintWriter(socket.getOutputStream(),true);
            
            while(true){
            
                String line = input.readLine();
               if(!line.contains("|") && line != null){
                    if(!isClientAdded(line)){
                        
                        Server.clients.put(socket, line);
                    }
                }else{
                    
                    System.out.println(line);
                    String[] msg = line.split("\\|");
                    
                    String fromUser = msg[0];
                    String toUser = msg[1];
                    String subject = msg[2];
                    String msgText = msg[3];
                    
                    if(isClientAdded(toUser)){
                        sendMsg(line);
                        if(timer.isRunning()){
                            timer.stop();
                        }
                    }else{
                        msgStack.add(line);
                        timer = new Timer(2000, new ActionListener() {
                            @Override
                            public void actionPerformed(ActionEvent e) {
                                System.out.println(msgStack+" "+msgStack.size());
                                if(isClientAdded(toUser)){
                                    if(!msgStack.isEmpty()){
                                        sendMsg(msgStack.poll());
                                        System.out.println("MSg: "+fromUser+" "+toUser+" "+subject+" "+msgText);
                                    }
                                    if(msgStack.isEmpty()){
                                        timer.stop();
                                    }
                                }
                            }
                        });
                        
                        timer.start();
                    }
                }
            }
            
        } catch (SocketException ex) {
            ex.printStackTrace();
            Server.clients.remove(socket);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
    
    public boolean isClientAdded(String clientName){
        
        Iterator it = Server.clients.entrySet().iterator();
                        while (it.hasNext()) {
                            Map.Entry pair = (Map.Entry)it.next();
                            if(clientName.equals(pair.getValue()+"")){
                                return true;
                            }
                            it.remove(); 
                    }
        return false;
    }
    
    public void sendMsg(String send){
        
        String[] msg = send.split("\\|");
                    
        String fromUser = msg[0];
        String toUser = msg[1];
        String subject = msg[2];
        String msgText = msg[3];
        
        Iterator it = Server.clients.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry pair = (Map.Entry)it.next();
                if((pair.getValue()+"").equals(toUser)){
                    
                    try {
                        socket = ((Socket)pair.getKey());
                        PrintWriter output = new PrintWriter(socket.getOutputStream(),true);
                        output.println(fromUser+"|"+subject+"|"+msg);
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
                 
             it.remove(); 
        }
    }
    
}