Java SocketTimeoutException:读取超时

这是一个简单的基于客户端/服务器的乒乓球程序。 不幸的是，它无法工作并显示以下错误消息：

java.net.SocketTimeoutException: Read timed out
    at java.net.SocketInputStream.socketRead0(Native Method)
    at java.net.SocketInputStream.read(Unknown Source)
    at java.net.SocketInputStream.read(Unknown Source)
    at sun.nio.cs.StreamDecoder.readBytes(Unknown Source)
    at sun.nio.cs.StreamDecoder.implRead(Unknown Source)
    at sun.nio.cs.StreamDecoder.read(Unknown Source)
    at java.io.InputStreamReader.read(Unknown Source)

它停在客户机任务30行，实际上客户机不读取服务器发送的内容。 代码如下：

服务器

包服务器客户端；
导入java.net。*；
导入java.io.*；
导入java.util.concurrent.*；
公共类服务器{
公共静态void main（字符串[]args）{
ExecutorService esp=Executors.newFixedThreadPool（50）；
try（ServerSocket ss=newserversocket（1027））{
while（true）{
试一试{
套接字s=ss.accept（）；
可调用任务=新服务器任务；
特别是提交（任务）；
}
catch（bindbe）{}
捕获（连接异常）{}
catch（noroutetohestexception nrthe）{}
catch（IOException ioe）{ioe.printStackTrace（）；}
}
}
catch（异常e）{e.printStackTrace（）；}
}
}

服务器任务

包服务器客户端；
导入java.util.concurrent.*；
导入java.net。*；
导入java.io.*；
公共类ServerTask实现可调用{
插座；
服务器任务（套接字）{
这个.s=s；
}
公开作废通知（）{
BufferedWriter=null；
BufferedReader reader=null；
试一试{
reader=new BufferedReader（new InputStreamReader（s.getInputStream（））；
writer=newbufferedwriter（newoutputstreamwriter（s.getOutputStream（））；
int i=0；
StringBuilder sb=新的StringBuilder（）；
而（（i=reader.read（））！=-1）{
某人附加（（字符）i）；
}
System.out.println（“客户端发送：“+sb”）；
作家。写（“乒乓球”）；
writer.flush（）；
}   
catch（IOException ioe）{ioe.printStackTrace（）；}
最后{
试一试{
writer.close（）；
} 
catch（IOException ioe）{ioe.printStackTrace（）；}
if（读卡器！=null）{
试一试{
reader.close（）；
}
catch（IOException ioe）{ioe.printStackTrace（）；}
}
试一试{
s、 close（）；
}
catch（IOException ioe）{ioe.printStackTrace（）；}
}
返回null；
}
}

客户

包服务器客户端；
导入java.io.IOException；
导入java.net。*；
导入java.util.concurrent.*；
公共类客户端{
公共静态void main（字符串[]args）{
ExecutorService es=Executors.newSingleThreadExecutor（）；
试一试{
套接字s=新套接字（InetAddress.getLocalHost（），1027）；
试一试{
s、 设置超时（50000）；
} 
catch（SocketException se）{se.printStackTrace（）；}
可调用任务=新客户端任务；
提交（任务）；
} 
catch（UnknownHostException uhe）{uhe.printStackTrace（）；}
catch（IOException ioe）{ioe.printStackTrace（）；}
}
}

客户端任务

包服务器客户端；
导入java.util.concurrent.*；
导入java.net。*；
导入java.io.*；
公共类ClientTask实现可调用{
插座；
客户端任务（套接字）{
这个.s=s；
}
公开作废通知（）{
BufferedWriter=null；
BufferedReader reader=null；
试一试{
writer=newbufferedwriter（newoutputstreamwriter（s.getOutputStream（））；
reader=new BufferedReader（new InputStreamReader（s.getInputStream（））；
作家。写（“平”）；
writer.flush（）；
int i=0；
StringBuilder sb=新的StringBuilder（）；
而（（i=reader.read（））！=-1）{
System.out.println（“我正在阅读”）；
某人附加（（字符）i）；
}
System.out.println（“服务器发送：“+sb”）；
}
catch（IOException ioe）{ioe.printStackTrace（）；}
最后{
试一试{
writer.close（）；
} 
catch（IOException ioe）{ioe.printStackTrace（）；}
if（读卡器！=null）{
试一试{
reader.close（）；
}
catch（IOException ioe）{ioe.printStackTrace（）；}
}
试一试{
s、 close（）；
}
catch（IOException ioe）{ioe.printStackTrace（）；}
}
返回null；
}
}

问题在于在

while

循环中使用

BufferedReader.read（）

与从连接另一侧处理套接字的方式之间的交互

.read（）

仅当从中读取的流结束时返回-1，在本例中，这基本上意味着套接字已关闭。在套接字关闭之前，服务器只是阻塞

读取

，等待客户端发送另一个字符。由于服务器正在阻塞

读取

，它将永远无法发送回“pong”。客户端正在阻止自己的读取，但最终会达到超时

TCP套接字用于处理数据流。如果您想使用它发送离散的消息，您需要在客户端和服务器之间强加一个协议，以便它们都知道完整消息何时到达。在这种情况下，客户机和服务器可以同意使用终止符字符来指定消息是完整的。例如，他们可以同意在每条消息之后发送一个作为终止符的

\n

例如，在您的客户机中，相关代码如下所示：

writer.write("ping");
writer.write('\n');
writer.flush();

int i=0;
StringBuilder sb=new StringBuilder();
while((i=reader.read())!=-1){
    char c = (char)i;
    if(c == '\n')
        break;
    sb.append(c);
}
System.out.println("The server sends: "+sb);

---

非常感谢，特别是你的解释！它现在正在运行，我学到了关于网络的另一件事^^

package serverClient;

import java.util.concurrent.*;
import java.net.*;
import java.io.*;

public class ServerTask implements Callable <Void> {

    Socket s;

    ServerTask(Socket s){
        this.s=s;
    }

    public Void call(){
        BufferedWriter writer=null;
        BufferedReader reader=null;

        try{

            reader=new BufferedReader(new InputStreamReader(s.getInputStream()));
            writer=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

            int i=0;
            StringBuilder sb=new StringBuilder();
            while((i=reader.read())!=-1){
                sb.append((char)i);
            }
            System.out.println("The client sends: "+sb);


            writer.write("pong");
            writer.flush();

        }   
        catch(IOException ioe){ioe.printStackTrace();}
        finally{

                try {
                    writer.close();
                } 
                catch (IOException ioe) {ioe.printStackTrace();}

            if(reader!=null){
                try{
                    reader.close();
                }
                catch(IOException ioe){ioe.printStackTrace();}
            }
            try{
                s.close();
            }
            catch(IOException ioe){ioe.printStackTrace();}

        }
        return null;
    }
}

package serverClient;

import java.io.IOException;
import java.net.*;
import java.util.concurrent.*;

public class Client {

    public static void main(String[] args) {

        ExecutorService es= Executors.newSingleThreadExecutor();

        try {

            Socket s= new Socket(InetAddress.getLocalHost(),1027);
            try {
                s.setSoTimeout(50000);
            } 
            catch(SocketException se){se.printStackTrace();}

            Callable<Void> task=new ClientTask(s);
            es.submit(task);

        } 
        catch (UnknownHostException uhe) {uhe.printStackTrace();} 
        catch (IOException ioe) {ioe.printStackTrace();}

    }

}

package serverClient;

import java.util.concurrent.*;
import java.net.*;
import java.io.*;

public class ClientTask implements Callable <Void>{

    Socket s;

    ClientTask(Socket s){
        this.s=s;
    }

    public Void call(){

        BufferedWriter writer=null;
        BufferedReader reader=null;

        try{

            writer=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            reader=new BufferedReader(new InputStreamReader(s.getInputStream()));

            writer.write("ping");
            writer.flush();

            int i=0;
            StringBuilder sb=new StringBuilder();
            while((i=reader.read())!=-1){
                System.out.println("I'm reading.");
                sb.append((char)i);
            }
            System.out.println("The server sends: "+sb);


        }
        catch(IOException ioe){ ioe.printStackTrace();}

        finally{

                try {
                    writer.close();
                } 
                catch (IOException ioe) {ioe.printStackTrace();}

            if(reader!=null){
                try{
                    reader.close();
                }
                catch(IOException ioe){ioe.printStackTrace();}
            }
            try{
                s.close();
            }
            catch(IOException ioe){ioe.printStackTrace();}

        }
        return null;
    }

}

writer.write("ping");
writer.write('\n');
writer.flush();

int i=0;
StringBuilder sb=new StringBuilder();
while((i=reader.read())!=-1){
    char c = (char)i;
    if(c == '\n')
        break;
    sb.append(c);
}
System.out.println("The server sends: "+sb);