我的SOCKET server就是不阻塞,在客户端CLOSE情况下还是继续读...

Question

服务器:import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerSocketTest {

 void startServer() throws IOException{
ServerSocket s = new ServerSocket(5678);
 
Socket c = s.accept();
DataInputStream in = new DataInputStream(c.getInputStream());
//BufferedReader in = new BufferedReader(new InputStreamReader(c
// .getInputStream()));
PrintWriter out = new PrintWriter(c.getOutputStream());

byte[] buffer=new byte[1024];
while(true)
{
int len = in.read(buffer, 0, 1024);

System.out.println("read len:"+len+":"+new String(buffer));

//String str = in.readLine();
//System.out.println("read "+str);
out.println("zyzy");
out.flush();
}
 
} public static void main(String[] args) throws IOException {

ServerSocketTest server= new ServerSocketTest();
server.startServer();
}
}客户端:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;public class Client2 {
static Socket server; int i = 0; int j = 0; String str; String strrev; public static void main(String[] args) throws Exception {
Client2 client = new Client2();
client.starttest();
} void starttest() throws UnknownHostException, IOException { server = new Socket("127.0.0.1", 5678); System.out.println("new Socket(InetAddress.getLocalHost(),6500)");
BufferedReader in = new BufferedReader(new InputStreamReader(server
.getInputStream()));
PrintWriter out = new PrintWriter(server.getOutputStream());
BufferedReader wt = new BufferedReader(new InputStreamReader(System.in)); str = new String();
try {
while (true) { str = "testtest"; out.println(str);
out.flush();
System.out.println("已发送:" + str);
strrev = in.readLine();
System.out.println("已接收:" + strrev); if (str.equals("end")) {
break;
}
i++;
j++; in.close();
out.close();
wt.close();
server.close();
break;
}
} catch (Exception ex) {
System.out.println("error:" + ex.getMessage());
} }}问题,在我的客户端程序结束之后,服务器程序仍然在运行...
不会停止 不会阻塞在int len = in.read(buffer, 0, 1024);处
不停的收到消息
read len:-1:testtest

Answer 1

 
Socket c = s.accept();
DataInputStream in = new DataInputStream(c.getInputStream());
//BufferedReader in = new BufferedReader(new InputStreamReader(c
// .getInputStream()));
PrintWriter out = new PrintWriter(c.getOutputStream());

byte[] buffer=new byte[1024];
while(true)
{
int len = in.read(buffer, 0, 1024);

System.out.println("read len:"+len+":"+new String(buffer));

//String str = in.readLine();
//System.out.println("read "+str);
out.println("zyzy");
out.flush();
}
 
}这个地方是个死循环，while(true)

Answer 2

对,是个死循环,我的意思是,如果阻塞,应该在while(true)
{
int len = in.read(buffer, 0, 1024);阻塞住
然后客户端CLOSE会触发异常来结束程序为什么没阻塞在int len = in.read(buffer, 0, 1024);??????????而一直System.out.println("read len:"+len+":"+new String(buffer));

Answer 3

void startServer() throws IOException
public static void main(String[] args) throws Exception
你这样异常等于是没处理，抛给操作系统了
void startServer(){
           try
           {
ServerSocket s = new ServerSocket(5678);
 
Socket c = s.accept();
DataInputStream in = new DataInputStream(c.getInputStream());
//BufferedReader in = new BufferedReader(new InputStreamReader(c
// .getInputStream()));
PrintWriter out = new PrintWriter(c.getOutputStream());

byte[] buffer=new byte[1024];
while(true)
{
int len = in.read(buffer, 0, 1024);

System.out.println("read len:"+len+":"+new String(buffer));

//String str = in.readLine();
//System.out.println("read "+str);
out.println("zyzy");
out.flush();
}
               }catch(Exception e){System.out.println("出错！");
 
}
  public static void main(String[] args){

ServerSocketTest server= new ServerSocketTest();
server.startServer();
}

Answer 4

参考下,和自己写的比对下
/**
   @version 1.20 2004-08-03
   @author Cay Horstmann
*/import java.io.*;
import java.net.*;
import java.util.*;/**
   This program makes a socket connection to the atomic clock
   in Boulder, Colorado, and prints the time that the
   server sends.
*/
public class SocketTest
{
   public static void main(String[] args)
   {
      try
      {
         Socket s = new Socket("127.0.0.1", 8189);
         try
         {
            InputStream inStream = s.getInputStream();
            Scanner in = new Scanner(inStream);            while (in.hasNextLine())
            {
               String line = in.nextLine();
               System.out.println(line);
            }
         }
         finally
         {
            s.close();
         }
      }
      catch (IOException e)
      {
         e.printStackTrace();
      }
   }
}
/**
   @author Cay Horstmann
   @version 1.20 2004-08-03
 */import java.io.*;
import java.net.*;
import java.util.*;/**
   This program implements a multithreaded server that listens to port 8189 and echoes back
   all client input.
 */
public class ThreadedEchoServer {
  public static void main(String[] args) {
    try {
      int i = 1;
      ServerSocket s = new ServerSocket(8189);      while (true) {
        Socket incoming = s.accept();
        System.out.println("Spawning " + i);
        BufferedReader in = new BufferedReader(new InputStreamReader(incoming.
            getInputStream()));
        while (in.readLine() != null)
          System.out.println("in.readLine()=" + in.readLine());
        while (in.read() != -1)
          System.out.println("in.read()=" + in.read());        Runnable r = new ThreadedEchoHandler(incoming, i);
        Thread t = new Thread(r);
        t.start();
        i++;
      }
    }
    catch (IOException e) {
      e.printStackTrace();
    }
  }
}/**
   This class handles the client input for one server socket connection.
 */
class ThreadedEchoHandler
    implements Runnable {
  /**
     Constructs a handler.
     @param i the incoming socket
     @param c the counter for the handlers (used in prompts)
   */
  public ThreadedEchoHandler(Socket i, int c) {
    incoming = i;
    counter = c;
  }  public void run() {
    try {
      try {
        InputStream inStream = incoming.getInputStream();
        OutputStream outStream = incoming.getOutputStream();        Scanner in = new Scanner(inStream);
        PrintWriter out = new PrintWriter(outStream, true /* autoFlush */);        out.println("Hello! Enter BYE to exit.");        // echo client input
        boolean done = false;
        while (!done && in.hasNextLine()) {
          String line = in.nextLine();
          out.println("Echo: " + line);
          if (line.trim().equals("BYE"))
            done = true;
        }
      }
      finally {
        incoming.close();
      }
    }
    catch (IOException e) {
      e.printStackTrace();
    }
  }  private Socket incoming;
  private int counter;
}

Answer 5

lixiaoxue85:
 关于异常不是问题所在,是客户机CLOSE后仍然SERVER在READ,而且得到-1的返回,并不阻塞

Answer 6

> 是客户机CLOSE后仍然SERVER在READ,而且得到-1的返回,并不阻塞就是因为对端关闭了连接，接收端才会返回 -1；如果连接有效，read() 才会阻塞。

Answer 7

maquan('ma:kju):
那按照你的说法,是否SERVER端只能显示的关闭了?
而不能通过CLIENT端关闭(潜在通知服务器端关闭)?

Answer 8

服务器是可以收到关闭信息的，是你没有判断而已
while(true)
{
int len = in.read(buffer, 0, 1024);
if(len < 0) break;//已经关闭了

Answer 9

ChDw(米):
服务器是可以收到关闭信息的，是你没有判断而已
while(true)
{
int len = in.read(buffer, 0, 1024);
if(len < 0) break;//已经关闭了
  
DataInputStream.read解释:
read
public final int read(byte[] b,
                      int off,
                      int len)
               throws IOException从所包含的输入流中将 len 个字节读入一个字节数组中。尽量读取 len 个字节，但可能读取较少的字节数，该字节数也可能为零。以整数形式返回实际读取的字节数。 
在输入数据可用、检测到文件末尾或抛出异常之前，此方法将阻塞。 如果 b 为 null，则抛出 NullPointerException。 如果 off 为负，或 len 为负，抑或 off+len 大于数组 b 的长度，则抛出 IndexOutOfBoundsException。 如果 len 为零，则不读取字节并返回 0；否则至少试图读取一个字节。如果因为该流在文件未尾而无字节可用，则返回 -1 值；否则至少读取一个字节并将其存储到 b 中。 
*********************
如果因为该流在文件未尾而无字节可用，则返回 -1 值??????
那么意思是?
CLOSE是得到-1,文件未尾而无字节可用返回-1如何解释??????????? 

Answer 10

在Socket关闭前，如果没有数据进入则read方法会处于阻塞状态，直到Client关闭了连接或者发送了新的数据到来。