Digital Ocean java服务器持续崩溃：java.net.SocketException:连接重置

我正在使用数字海洋服务器来促进我的PC游戏中的在线多人游戏。服务器是一个用Java编写的小型应用程序。问题是服务器偶尔会停止运行，大约15分钟后会自动重新启动。我已经升级了几次服务器，但似乎没有什么不同，最后我使用的是一个CPU优化的Droplet，具有4 GB内存、2个VCPU和20 GB磁盘。我不完全确定，但当大约有15人在线时，服务器似乎关闭了，但有时在线人数相同（或更多），并且没有崩溃发生。当大多数人在线时，它每天崩溃1-2次

图表：

-服务器崩溃后1分钟（晚上7:29）：

-服务器关闭12分钟（下午7:41）：

-服务器重新联机（下午7:50）：

-服务器恢复联机28分钟（晚上8:18）：

控制台：

-服务器崩溃后（晚上7:39）： 它表明：

java.net.SocketException: Connection reset

-服务器重新联机后（晚上7:50）：

我唯一能识别的是ClientThread.java文件，它是构成服务器的3个java文件之一。 我还必须说，我对Java的经验非常基础，其他人制作了Java服务器文件（他们不可用），但我了解其中的大部分内容，并且自己做了一些小的调整

这台服务器偶尔崩溃有什么原因吗

以下是ClientThread.java文件：

import java.util.Iterator;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStreamReader;
import java.util.regex.Pattern;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.net.Socket;

// 
// Decompiled by Procyon v0.5.30
// 

public class ClientThread extends Thread
{
    Socket clientSocket_;
    String clientIp_;
    String serverIp_;
    ServerInformation server_;
    PrintWriter out_;
    BufferedReader in_;
    boolean prepareTermination_;
    boolean terminated_;
    private static final Pattern numberPattern;

    static {
        numberPattern = Pattern.compile("\\d+");
    }

    public ClientThread(final Socket sock) {
        this.clientSocket_ = sock;
        this.clientIp_ = this.clientSocket_.getRemoteSocketAddress().toString();
        this.serverIp_ = null;
        this.server_ = null;
        this.prepareTermination_ = false;
        this.terminated_ = false;
    }

    @Override
    public void run() {
        try {
            //this.logDebugMessage(2, "Client socket accepted, ip: " + this.clientIp_);
            this.out_ = new PrintWriter(this.clientSocket_.getOutputStream(), true);
            this.in_ = new BufferedReader(new InputStreamReader(this.clientSocket_.getInputStream()));
            long lastActionTime = System.currentTimeMillis();
            while (true) {
                if (this.in_.ready() || System.currentTimeMillis() - lastActionTime >= 1000 * Main.threadTimeout_) {
                    if (System.currentTimeMillis() - lastActionTime >= 1000 * Main.threadTimeout_) {
                        //this.logDebugMessage(3, "Thread was killed due to prolonged inactivity (" + Main.threadTimeout_ + " seconds)");
                        this.terminateThread();
                        return;
                    }
                    lastActionTime = System.currentTimeMillis();
                    final String inputLine = this.in_.readLine().trim();
                    if (ClientThread.numberPattern.matcher(inputLine).matches()) {
                        final int val = Integer.parseInt(inputLine);
                        switch (val) {
                            case 111: { //send to client fast b
                                final StringBuilder msg = new StringBuilder();
                                    msg.append(String.valueOf(this.in_.readLine().trim()));
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {
                                    if (thread2 != this) {
                                        thread2.out_.print(msg);
                                        thread2.out_.flush();
                                    }
                                }
                                break;
                            }                           
                            case 110: { //send to ip fast
                                final String ip = this.in_.readLine().trim();
                                final ClientThread target = this.server_.ipToClientThread_.getOrDefault(ip, null);
                                if (target != null) {
                                    target.out_.print(this.in_.readLine().trim());
                                    target.out_.flush();
                                    break;
                                }                               
                            }                               
                            case 109: { //send to server fast
                                this.server_.out_.print(this.in_.readLine().trim());
                                this.server_.out_.flush();
                                break;
                            }                               
                            case 108: { //send to all fast
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {          
                                        thread2.out_.print(this.in_.readLine().trim());
                                        thread2.out_.flush();
                                }
                                break;
                            }                           
                            case 107: { //send to others fast
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {
                                    if (thread2 != this) {
                                        thread2.out_.print(this.in_.readLine().trim());
                                        thread2.out_.flush();
                                    }
                                }
                                break;
                            }                           
                            case 106: {
                                this.server_.description_ = this.in_.readLine().trim(); //class                             
                                break;
                            }                                                           
                            case 105: {
                                this.out_.print("*" + 26 + "|" + this.server_.servervar3_ + "|" + this.server_.servervar4_ + "|" + this.server_.servervar5_ + "~" + "|");
                                this.out_.flush();
                                break;
                            }                               
                            case 104: {
                                this.server_.servervar5_ = this.in_.readLine().trim(); //status         
                                break;
                            }                                   
                            case 103: {
                                this.server_.servervar3_ = this.in_.readLine().trim(); //current lap                
                                break;
                            }                                       
                            case 102: {
                                this.server_.servervar3_ = this.in_.readLine().trim(); //current lap
                                this.server_.servervar4_ = this.in_.readLine().trim(); //total laps
                                this.server_.servervar5_ = this.in_.readLine().trim(); //status                     
                                break;
                            }                       
                            case 101: { //admin quit server
                                final String ipServer = this.in_.readLine().trim();
                                final ServerInformation info = Main.servers_.getOrDefault(ipServer, null);
                                this.server_ = info;                
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {
                                        thread2.out_.print("*" + 22 + "|" + -1 + "~" + "|");
                                        thread2.out_.flush();
                                }                                   
                                //this.logDebugMessage(1, "A game server has been deleted, ip: " + ipServer);
                                Main.servers_.remove(ipServer);                                                     
                                break;
                            }                           
                            case 100: { 
                                if (System.currentTimeMillis() - this.server_.servervar2_ >= 1000 * 20) { //clients check if server is still online
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {
                                        thread2.out_.print("*" + 22 + "|" + -1 + "~" + "|");
                                        thread2.out_.flush();          
                                }                                   
                                final String ipServer = this.server_.ip_;
                                //this.logDebugMessage(1, "A game server has been deleted, ip: " + ipServer);
                                Main.servers_.remove(ipServer);
                                }
                                break;
                            }                           
                            case 99: {
                                this.server_.servervar2_ = System.currentTimeMillis(); //send server last update
                                break;
                            }
                            case 98: {
                                final String ipServer = this.in_.readLine().trim();
                                //this.logDebugMessage(1, "A game server has been deleted, ip: " + ipServer);
                                Main.servers_.remove(ipServer);
                                this.serverIp_ = null;
                                for (final ClientThread thread : this.server_.ipToClientThread_.values()) {
                                    thread.prepareTermination_ = true;
                                }
                                this.terminateThread();
                                return;
                            }
                            case 96: {
                                final String ipServer = this.in_.readLine().trim();
                                final String ipClient = this.in_.readLine().trim(); 
                                //this.logDebugMessage(1, "A client wishes to connect to a server, client: " + ipClient + ", server: " + ipServer);
                                final ServerInformation info = Main.servers_.getOrDefault(ipServer, null);
                                if (info == null) {
                                    System.out.println("Connection to the server failed, no such server in the server list");
                                    out_.print("*" + 1 + "|" + 1 + "~" + "|");
                                    out_.flush();                                   
                                break;
                                }
                                this.server_ = info;
                                this.server_.ipToClientThread_.put(ipClient, this);
                                this.server_.numplayers_ += 1;
                                //this.logDebugMessage(1, "Connection success");
                                    out_.print("*" + 1 + "|" + 2 + "~" + "|");
                                    out_.flush();
                                break;
                            }
                            case 95: {
                                final String ipClient = this.in_.readLine().trim();
                                this.server_.ipToClientThread_.remove(this);
                                this.server_.numplayers_ -= 1;
                                //this.logDebugMessage(1, String.valueOf(ipClient) + " disconnected from the server at " + this.server_.ip_);
                                this.terminateThread();
                                return;
                            }
                            case 94: {
                                final int parseCount = Integer.parseInt(this.in_.readLine().trim());
                                final StringBuilder msg = new StringBuilder();
                                for (int i = 0; i < parseCount; ++i) {
                                    msg.append(String.valueOf(this.in_.readLine().trim()) + "|");
                                }
                                this.server_.out_.print(msg.toString());
                                this.server_.out_.flush();
                                //this.logDebugMessage(5, "Packet for server: '" + msg.toString() + "'");
                                break;
                            }
                            case 93: {
                                final int parseCount = Integer.parseInt(this.in_.readLine().trim());
                                final String ip = this.in_.readLine().trim();
                                final StringBuilder msg = new StringBuilder();
                                for (int i = 0; i < parseCount - 1; ++i) {
                                    msg.append(String.valueOf(this.in_.readLine().trim()) + "|");
                                }
                                final ClientThread target = this.server_.ipToClientThread_.getOrDefault(ip, null);
                                if (target != null) {
                                    target.out_.print(msg.toString());
                                    target.out_.flush();
                                    //this.logDebugMessage(5, "Packet for " + ip + ": '" + msg.toString() + "'");
                                    break;
                                }
                                //this.logDebugMessage(1, "Packet for " + ip + " failed to send (recipient not found)");
                                break;
                            }
                            case 92: {
                                final int parseCount = Integer.parseInt(this.in_.readLine().trim());
                                final StringBuilder msg = new StringBuilder();
                                for (int j = 0; j < parseCount; ++j) {
                                    msg.append(String.valueOf(this.in_.readLine().trim()) + "|");
                                }
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {
                                    thread2.out_.print(msg);
                                    thread2.out_.flush();
                                }
                                //this.logDebugMessage(5, "Packet for all: '" + msg.toString() + "'");
                                break;
                            }
                            case 91: {
                                final int parseCount = Integer.parseInt(this.in_.readLine().trim());
                                final StringBuilder msg = new StringBuilder();
                                for (int j = 0; j < parseCount; ++j) {
                                    msg.append(String.valueOf(this.in_.readLine().trim()) + "|");
                                }
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {
                                    if (thread2 != this) {
                                        thread2.out_.print(msg);
                                        thread2.out_.flush();
                                    }
                                }
                                //this.logDebugMessage(5, "Packet for others: '" + msg.toString() + "'");
                                break;
                            }
                            case 90: {
                                //this.logDebugMessage(2, "A socket has requested the advanced server list, server list size: " + Main.servers_.size());
                                if (Main.servers_.size()==0) {
                                    this.out_.print("*" + 0 + "|" + 0 + "|" + 0 + "|" + 0 + "|" + 0 + "|" + 0 + "|" + 0 + "~" + "|");   
                                } else {
                                for (final ServerInformation info2 : Main.servers_.values()) {
                                    this.out_.print("*" + String.valueOf(info2.name_) + "|" + info2.ip_ + "|" + info2.description_ + "|" + info2.servervar1_ + "|"  + info2.servervar2_ + "|"  + info2.servervar3_ + "|"  + info2.servervar4_ + "|"  + info2.servervar5_ + "|" + info2.numplayers_ + "|" + info2.ipToClientThread_.size() + "|"  + info2.servervar6_ + "|"  + info2.servervar7_ + "~" + "|");
                                if (System.currentTimeMillis() - info2.servervar2_ >= 1000 * 20) {
                                final String ipServer = info2.ip_;
                                final ServerInformation info = Main.servers_.getOrDefault(ipServer, null);
                                this.server_ = info;                
                                for (final ClientThread thread2 : this.server_.ipToClientThread_.values()) {
                                        thread2.out_.print("*" + 22 + "|" + -1 + "~" + "|");
                                        thread2.out_.flush();
                                }                                   
                                //this.logDebugMessage(1, "A game server has been deleted, ip: " + ipServer);
                                Main.servers_.remove(ipServer);
                                }                                                           
                                }                               
                                }
                                this.out_.flush();
                                break;
                            }
                            case 89: {
                                final String ipServer = this.in_.readLine().trim();
                                final String name = this.in_.readLine().trim(); //Server name
                                final String description = this.in_.readLine().trim(); //class
                                final String servervar1 = this.in_.readLine().trim(); //max players
                                final String servervar3 = this.in_.readLine().trim(); //current lap
                                final String servervar4 = this.in_.readLine().trim(); //total laps
                                final String servervar5 = this.in_.readLine().trim(); //status
                                final String servervar6 = this.in_.readLine().trim(); //Password
                                final String servervar7 = this.in_.readLine().trim(); //Online version
                                //this.logDebugMessage(1, "A game server has been registered, ip: " + ipServer + ", name: " + name + ", description: " + description + ", servervar1: " + servervar1);
                                final ServerInformation gameServer = new ServerInformation(name, servervar1, servervar3, servervar4, servervar5, servervar6, servervar7, ipServer, this.clientSocket_, this.out_, this.in_);
                                gameServer.description_ = description;
                                gameServer.ipToClientThread_.put(ipServer, this);
                                this.server_ = gameServer;
                                Main.servers_.put(ipServer, gameServer);
                                this.serverIp_ = ipServer;
                                break;
                            }
                            default: {
                                //this.logDebugMessage(0, "Unrecognized case: '" + inputLine + "', " + val);
                                break;
                            }
                        }
                    }
                    else if (inputLine.length() > 0) {
                        //this.logDebugMessage(0, "Unformated '" + inputLine + "'");
                        if (this.server_ != null) {
                            this.server_.out_.print(inputLine);
                            this.server_.out_.flush();
                        }
                    }
                    if (this.prepareTermination_) {
                        this.terminateThread();
                        return;
                    }
                    continue;
                }
            }
        }
        catch (IOException e) {
            e.printStackTrace();
            try {
                this.terminateThread();
            }
            catch (IOException e2) {
                e2.printStackTrace();
            }
        }
    }

    void logDebugMessage(final int requiredVerbose, final String msg) {
        if (Main.verboseLevel_ >= requiredVerbose) {
            System.out.println("[" + this.clientIp_ + "]  " + msg);
        }
    }

    void terminateThread() throws IOException {
        if (!this.terminated_) {
            if (this.serverIp_ != null) {
                Main.servers_.remove(this.serverIp_);
            }
            this.clientSocket_.close();
            this.in_.close();
            this.out_.close();
            //this.logDebugMessage(3, "Cleanup successful");
            this.terminated_ = true;
        }
    }
}

import java.util.Iterator；
导入java.io.IOException；
导入java.io.Reader；
导入java.io.InputStreamReader；
导入java.util.regex.Pattern；
导入java.io.BufferedReader；
导入java.io.PrintWriter；
导入java.net.Socket；
// 
//由Procyon v0.5.30反编译
// 
公共类ClientThread扩展线程
{
插座客户端插座；
字符串clientIp；
字符串服务器IP；
服务器信息服务器；
打印输出；
缓冲读取器；
布尔预处理；
布尔终止；
私有静态最终模式编号模式；
静止的{
numberPattern=Pattern.compile（\\d+）；
}
公共客户端线程（最终套接字套接字）{
this.clientSocket=sock；
this.clientIp=this.clientSocket_u.getRemoteSocketAddress（）.toString（）；
this.serverIp=null；
this.server=空；
此.prepareTermination=假；
this.terminated=false；
}
@凌驾
公开募捐{
试一试{
//this.logDebugMessage（2，“已接受客户端套接字，ip:+this.clientIp)）；
this.out u=新的PrintWriter（this.clientSocket_uz.getOutputStream（），true）；
this.in=新的BufferedReader（新的InputStreamReader（this.clientSocket_uu.getInputStream（））；
long lastActionTime=System.currentTimeMillis（）；
while（true）{
if（this.in|.ready（）| System.currentTimeMillis（）-lastActionTime>=1000*Main.threadTimeout）{
if（System.currentTimeMillis（）-lastActionTime>=1000*Main.threadTimeout）{
//此.logDebugMessage（3，“线程由于长时间不活动（“+Main.threadTimeout u+”秒）”而被终止）；
这个.terminateThread（）；
返回；
}
lastActionTime=System.currentTimeMillis（）；
final String inputLine=this.in.readLine（）.trim（）；
if（ClientThread.numberPattern.matcher（inputLine.matches（））{
final int val=Integer.parseInt（inputLine）；
开关（val）{
案例111:{//send to client fast b
最终StringBuilder msg=新StringBuilder（）；
msg.append（String.valueOf（this.in.readLine（）.trim（））；
对于（最终ClientThread2:this.server_u2;.ipToClientThread_2;.values（））{
如果（thread2！=此）{
线程2.输出打印（msg）；
螺纹2.外螺纹齐平（）；
}
}
打破
}                           
案例110:{//发送到ip fast
最后一个字符串ip=this.in.readLine（）.trim（）；
final ClientThread target=this.server\uu0.ipToClientThread\u0.getOrDefault（ip，null）；
如果（目标！=null）{
target.out.print（this.in.readLine（）.trim（））；
target.out..flush（）；
打破
}                               
}                               
案例109:{//快速发送到服务器
this.server\ out\打印（this.in\ readLine（）.trim（））；
this.server_u.out_u.flush（）；
打破
}                               
案例108:{//发送给所有fast
对于（最终ClientThread2:this.server_u3;.ipToClientThread_3;.values（））{
线程2.输出打印（此.in.读取线（）.trim（））；
螺纹2.外螺纹齐平（）；
}
打破
}                           
案例107:{//快速发送给其他人
对于（最终ClientThread2:this.server_u2;.ipToClientThread_2;.values（））{
如果（thread2！=此）{
for (final ServerInformation info2 : Main.servers_.values())

Map<String, String> myMap = new ConcurrentHashMap<String, String>();
myMap.put("1", "1");
myMap.put("2", "2");
myMap.put("3", "3");

Iterator<String> it1 = myMap.keySet().iterator();
while (it1.hasNext()) {
    String key = it1.next();
    System.out.println("Map Value:" + myMap.get(key));
    if (key.equals("1")) {
        myMap.remove("3");
        myMap.put("4", "4");
        myMap.put("5", "5");
    }
}

Map Value:1
Map Value:2
Map Value:4
Map Value:5

final String tempInputLine;

if((tempInputLine = this.in_.readLine()) == null ){
    //close
    this.terminateThread();
    return;
}
else{

    final String inputLine = tempInputLine.trim();
    if (ClientThread.numberPattern.matcher(inputLine).matches()){
        //...
    }
    //..
}