1. import java.io.IOException;
   
2. import java.net.ServerSocket;
   
3. import java.net.Socket;
   
4. import java.net.UnknownHostException;
   
5. 
   
6. public class TCPDemo {
   
7. 
   
8.         public static void main(String[] args) {
   
9.                 class Server{
   
10.                         private ServerSocket mServer;
    
11.                         private Socket mClient;
    
12.                        
    
13.                        
    
14.                         public void begin() throws IOException{
    
15.                                 mServer = new ServerSocket(60000);
    
16.                                 mClient = mServer.accept();
    
17.                                
    
18.                                 mClient.getOutputStream().write("nihao".getBytes());
    
19.                                 System.out.println("server send over");
    
20.                                
    
21.                                 mClient.close();
    
22.                                 mServer.close();
    
23.                                 System.out.println("server  over");
    
24.                         }
    
25.                 }
    
26.                 class Client{
    
27.                         private Socket mClient;
    
28.                        
    
29.                         public void begin() throws UnknownHostException, IOException, InterruptedException{
    
30.                                 mClient = new Socket("127.0.0.1", 60000);
    
31.                                 Thread.sleep(3000);
    
32.                                 System.out.println("Client recevice data");
    
33.                                
    
34.                                 System.out.println(mClient.getInputStream().read());
    
35.                         }
    
36.                 }
    
37.                
    
38.                 new Thread(new Runnable(){
    
39.                         @Override
    
40.                         public void run() {
    
41.                                 try {
    
42.                                         new Server().begin();
    
43.                                 } catch (IOException e) {
    
44.                                         // TODO Auto-generated catch block
    
45.                                         e.printStackTrace();
    
46.                                 }
    
47.                         }
    
48.                        
    
49.                 }).start();
    
50.                
    
51.                 new Thread(new Runnable(){
    
52.                         @Override
    
53.                         public void run() {
    
54.                                 try {
    
55.                                         new Client().begin();
    
56.                                 } catch (UnknownHostException e) {
    
57.                                         // TODO Auto-generated catch block
    
58.                                         e.printStackTrace();
    
59.                                 } catch (IOException e) {
    
60.                                         // TODO Auto-generated catch block
    
61.                                         e.printStackTrace();
    
62.                                 } catch (InterruptedException e) {
    
63.                                         // TODO Auto-generated catch block
    
64.                                         e.printStackTrace();
    
65.                                 }
    
66.                         }
    
67.                        
    
68.                 }).start();
    
69.         }
    
70.        
    
71.        
    
72. }
    

复制代码

我的思路是这样的。 开启了 服务器 和客户端。  客户端 连接上服务器， 服务器在 连接之后，会给 客户端发送 数据，然后关闭。而 客户端 连接上了 之后， sleep 3s 再接收数据。我的 问题是 ，客户端 sleep 醒来之后， 服务器 早就 关闭了 连接，那为什么
客户端还能从 流中 读取数据。

skill20 发表于 2014-5-2 20:07
都放一个类的方法里了。。。

应该 和这个 没关系 把

都放一个类的方法里了。。。