我用dataInputStream.readUTF()可以读出值，为什么改用BufferedReader.readLine()就不行了捏？

Question

如题，在线程中应用dataInputStream.readUTF()时候，一切运行正常，如果改用BufferedReader.readLine()，线程就因为读不出数值 一直在等待，为什么呢？

Answer 1

因为readLine的意思是一直读直至回车符或者流结束
可能你使用了网络流（Soccket之类），但是对方并没有发送回车而且没有结束流，所以你的程序在等待
如果是网络流，你应该在收取数据前先与服务器沟通一下，知道传递过来的数据有多长，又或者以什么作为结束符，否则是无法正确的完整接收到服务器的数据

Answer 2

谢谢，程序有点麻烦，我可以加分 import java.io.*;
import java.net.*;
import java.nio.channels.IllegalBlockingModeException;
import java.util.Scanner;public class ClientSocket {

String destIp;
int destPort;
int timeout;

protected BufferedReader socketReader;
protected PrintWriter socketWriter;

Socket s;
public ClientSocket(String destIp,int destPort,int timeout){
this.destIp = destIp;
this.destPort = destPort;
this.timeout = timeout;
}

public String creatSocket(){
String message = null;
s = new Socket();
try{
s.connect(new InetSocketAddress(destIp,destPort), timeout);
s.setSoTimeout(1000);
s.setTcpNoDelay(true);//禁用 Nagle 算法,即时发送数据包
//为达到最高读取效率，用BufferedReader包装InputStreamReader
socketReader = new BufferedReader(new InputStreamReader(s.getInputStream()));
socketWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter( s.getOutputStream())),true);
}catch(SocketTimeoutException e){
message = "连接超时！";
e.printStackTrace();
}catch(IllegalBlockingModeException e){
message = "连接受阻塞！";
e.printStackTrace();
}catch(IllegalArgumentException e){
if(destIp == null){
message = "未指定主机地址！";
}else
message = "端口号超出有效范围！";
e.printStackTrace();
}catch(UnknownHostException e){
message = "未知的主机地址："+destIp;
e.printStackTrace();
}catch(IOException e){
message = "连接中断，或连接失败！";
e.printStackTrace();
}catch(SecurityException e){
message = "没有解析主机地址的权限！";
e.printStackTrace();
}
return message;
}

public void tearDownConnection() {
        try {
            socketWriter.close();
            socketReader.close();
        } catch (IOException e) {
            System.out.println("关闭socket连接时出现错误: " + e);
        }
    } public String transfer(String info){
StringBuffer lines = new StringBuffer();
System.out.println("1--"+s.isClosed());

//使用内部类实现读线程，可以使同一次读和写操作在程序结构上完整联系在一起
class ReaderThread extends Thread{
StringBuffer tempLines = new StringBuffer();
public void run(){
String line = null;
try {
System.out.println("2--"+s.isClosed());

while(!s.isClosed() && ((line = socketReader.readLine()) != null)){
tempLines.append(line + "\n");
}
} catch(ConnectException e){
System.out.println("远程连接被拒绝!");
}catch(NoRouteToHostException e){
System.out.println("主机无法到达，可能受防火墙干扰或路由器停机！");
}catch(PortUnreachableException e){
System.out.println("目标主机端口无法到达，可能受防火墙干扰！");
}catch(SocketException e){
System.out.println("连接已断开!");
e.printStackTrace();
}catch(IOException e){
System.out.println("传输错误!");
e.printStackTrace();
}
}

public StringBuffer getLines(){
return tempLines;
}
}

//try{
socketWriter.print(info+"\n");//通过写入行分隔符字符串终止当前行
socketWriter.flush();//立时刷新缓存


System.out.println("3--"+s.isClosed());
ReaderThread reader = new ReaderThread();
reader.start();
lines = reader.getLines();
System.out.println("4--"+s.isClosed());
try{
Thread.sleep(500);//等待server端的返回
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return lines.toString();
}


public static void main(String[] args){
System.out.println("输入主机地址：");
Scanner scanner = new Scanner(System.in);
String ip = null;
if(scanner.hasNext())
ip = scanner.next();
if(null == ip || "".equals(ip.trim())){
System.out.println("主机地址不能为空！");
}else
scanner.close();
ClientSocket clientSocket = new ClientSocket(ip,8189,1000);

String message = clientSocket.creatSocket();
if(message != null){
throw new RuntimeException(message);
}
System.out.println("输入发送主机的信息：");
String contents = clientSocket.transfer("asdfsad");
clientSocket.tearDownConnection();
System.out.println(contents);
}}

Answer 3

下面是服务器的代码，可以在本地机器上运行测试一下import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class EchoServer {
public static void main(String[] args) {
EchoServerWriter serverWriter;
EchoServerReader serverReader;
try {
ServerSocket s = new ServerSocket(8189);
Socket incoming = s.accept();
serverReader = new EchoServerReader(incoming.getInputStream());
serverWriter = new EchoServerWriter(incoming.getOutputStream(),serverReader.pipedWriter);
serverReader.start();
serverWriter.start();
}catch(IOException e){
e.printStackTrace();
}
}
}class EchoServerReader extends Thread {
DataInputStream dis;
PipedWriter pipedWriter;
public EchoServerReader(InputStream inputStream) {
dis = new DataInputStream(inputStream);
pipedWriter = new PipedWriter();
// TODO Auto-generated constructor stub
}
public void run() {
try{
while (true) {
 
String str;
str = dis.readUTF();
pipedWriter.write(str);
if(str.equals("BYE"))
break;
}   

}catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} 

}
}class EchoServerWriter extends Thread{
DataOutputStream dos;
InputStreamReader reader = new InputStreamReader(System.in) ;
BufferedReader br = new BufferedReader(reader);
PipedReader pipedReader;
public EchoServerWriter(OutputStream outputStream,PipedWriter pipedWriter){
dos = new DataOutputStream(outputStream);
try {
pipedReader = new PipedReader(pipedWriter);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void run(){
try {
dos.writeUTF("Hello!Enter BYE to exit.");
while(true){
char[] chars = new char[1024];
int i = 0;
i = pipedReader.read(chars);
String temp = new String(chars,0,i);
System.out.println("Server says:"+temp);
dos.writeUTF("Echo:"+temp+"\n");
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}  
}
}