1. import java.io.*;
   
2. import java.net.*;
   
3. class  LoginClient
   
4. {
   
5.         public static void main(String[] args) throws Exception
   
6.         {
   
7.                 Socket s=new Socket("192.168.1.101",10009);
   
8. 
   
9.                 BufferedReader br=
   
10.                         new BufferedReader(new InputStreamReader(System.in));
    
11. 
    
12.                 BufferedReader sbr=
    
13.                         new BufferedReader(new InputStreamReader(s.getInputStream()));
    
14.                
    
15.                 PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
    
16. 
    
17.                 for(int i=0;i<3;i++)
    
18.                 {
    
19.                         String name=br.readLine();                        
    
20.                         if(name==null)
    
21.                         break;
    
22.                         pw.println(name);
    
23.                         String info=sbr.readLine();
    
24.                         System.out.println("服务器："+info);        
    
25.                         if(info.contains("欢迎"))
    
26.                         break;
    
27.                 }
    
28.                 br.close();
    
29.                 s.close();
    
30.         }
    
31. }
    
32. 
    
33. 
    
34. 
    
35. 
    
36. class LoginServer
    
37. {
    
38.         public static void main(String[] args) throws Exception
    
39.         {
    
40.                 ServerSocket ss=new ServerSocket(10009);
    
41.                 while(true)
    
42.                 {
    
43.                         Socket s=ss.accept();
    
44.                         new Thread(new UserLogin(s)).start();               
    
45.                 }
    
46. 
    
47.         }
    
48. }
    
49. 
    
50. 
    
51. 
    
52. 
    
53. 
    
54. 
    
55. 
    
56. class UserLogin implements Runnable
    
57. {
    
58.         private Socket s=null;
    
59.         
    
60.         UserLogin(Socket s)
    
61.         {
    
62.         this.s=s;
    
63.         }
    
64. 
    
65.         public void run()
    
66.         {
    
67.         String ip=s.getInetAddress().getHostAddress();
    
68.         System.out.println(ip+"...connected");
    
69.         
    
70.                
    
71.                         BufferedReader sbr=null;
    
72.                         PrintWriter spw=null;               
    
73.                         try
    
74.                         {
    
75.                                 sbr=
    
76.                                 new BufferedReader(new InputStreamReader(s.getInputStream()));
    
77.                                 spw=
    
78.                                 new PrintWriter(s.getOutputStream(),true);
    
79.                         }
    
80.                         catch (Exception e)
    
81.                         {
    
82.                                 throw new RuntimeException(ip+"Socket输入输出流出现问题");
    
83.                         }
    
84.                
    
85.         
    
86.         for(int i=0;i<3;i++)
    
87.                 {                                
    
88.                         BufferedReader br=null;
    
89.                         try
    
90.                         {
    
91.                                 br=new BufferedReader(new FileReader("UserName.txt"));
    
92.                         }
    
93.                         catch (Exception e)
    
94.                         {
    
95.                         
    
96.                         }
    
97. 
    
98. 
    
99.                         String name=null;
    
100. 
     
101.                         try
     
102.                         {
     
103.                                 name=sbr.readLine();
     
104.                                 
     
105.                         }
     
106.                         catch (Exception e)
     
107.                         {
     
108.                         throw new RuntimeException("输入流读取出现问题1");
     
109.                         }        
     
110. 
     
111. 
     
112. 
     
113. 
     
114. //if(name==null)
     
115. //break;
     
116.                         String line=null;               
     
117.                         boolean flag=false;
     
118. 
     
119. 
     
120.                         try
     
121.                         {
     
122.                                 while((line=br.readLine())!=null)
     
123.                                 {               
     
124.                                         System.out.println(line);
     
125.                                         if(line.equals(name))
     
126.                                         {
     
127.                                                         
     
128.                                                         flag=true;
     
129.                                                         break;
     
130.                                         }                        
     
131.                                 }
     
132.                         }
     
133.                         catch (Exception e)
     
134.                         {
     
135.                                 throw new RuntimeException("输入流读取出现问题2");
     
136.                         }
     
137. 
     
138.                         
     
139.                         if(flag)
     
140.                         {
     
141.                                 System.out.println(name+"登陆成功");               
     
142.                                 spw.println("登陆成功--欢迎");
     
143.                                 break;
     
144.                         }
     
145.                         else
     
146.                                 System.out.println(name+"尝试登陆");
     
147.                                 spw.println(name+"登陆失败");        
     
148.                
     
149. 
     
150.                
     
151. 
     
152.         
     
153.                         try
     
154.                         {
     
155.                                         br.close();
     
156.                         }
     
157.                         catch (Exception e)
     
158.                         {
     
159.                                 throw new RuntimeException("关闭异常1");
     
160.                         }
     
161.                
     
162. 
     
163. 
     
164.                 }
     
165.                
     
166. 
     
167.         
     
168.                         try
     
169.                         {
     
170.                                         s.close();
     
171.                         }
     
172.                         catch (Exception e)
     
173.                         {
     
174.                                 throw new RuntimeException("关闭异常2");
     
175.                         }
     
176. 
     
177.         }
     
178. }

复制代码

为了更好的表达我的问题，我将全部代码复制如上。同时为了发现异常发生的位置，我将服务端的代码分别进行了try.我的问题是：
1.用户在客户端进行了ctrl+c操作，按照毕老师视频里的展示，当不判断返回为null的情况下，则会在服务端提示null尝试登陆两次失败，但是我的实际演示情况是——有时会像毕老师演示的结果，有时则会在服务端socket输入流进行readLine()操作时会报异常，也就是说，不一定会发生什么情况，随即的。为什么会发生这种情况呢？（PS：我用的是jdk1.7，会不会跟我的jdk版本有关系？）
2.还是1的问题，按照我的正常理解，当客户端把socket资源关闭了以后，服务端再读取socket的输入流理所当然的会报异常，因为数据源已经关闭了，为什么在毕老师的视频里还会返回null呢？

你看看这个，好像我也只修改了IP地址。我这也是1.7的，是对的啊。
package networkprogramming;

/*
客户端通过键盘录入用户名。
服务器对这个用户名进行校验。

如果该用户存在，在服务端显示xxx，已登录。
并在客户端显示xxx ，欢迎光临。

如果该用户存在，在服务端显示xxx，尝试登陆。
并在客户端显示xxx，该用户不存在。

最多就登陆三次。

*/

import java.io.*;
import java.net.*;

class  LoginClient
{
        public static void main(String[] args) throws Exception {
                Socket s=new Socket("192.168.0.101",10009);
                BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
                BufferedReader sbr= new BufferedReader(new InputStreamReader(s.getInputStream()));
                PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
        for(int i=0;i<3;i++) {
                String name=br.readLine();                        
            if(name==null)
                    break;
            pw.println(name);
            String info=sbr.readLine();
            System.out.println("服务器："+info);        
            if(info.contains("欢迎"))
                 break;
        }
        br.close();
        s.close();
    }
}

class LoginServer
{
        public static void main(String[] args) throws Exception {
                ServerSocket ss=new ServerSocket(10009);
                while(true) {
                        Socket s=ss.accept();
                        new Thread(new UserLogin(s)).start();
                }
        }
}

class UserLogin implements Runnable {
        private Socket s=null;      
        UserLogin(Socket s) {
                this.s=s;
        }
        public void run() {
                String ip=s.getInetAddress().getHostAddress();
        System.out.println(ip+"...connected");                       
        BufferedReader sbr=null;
        PrintWriter spw=null;               
        try {
                sbr=new BufferedReader(new InputStreamReader(s.getInputStream()));
                spw= new PrintWriter(s.getOutputStream(),true);
        } catch (Exception e) {
                throw new RuntimeException(ip+"Socket输入输出流出现问题");
        }
        for(int i=0;i<3;i++) {
                BufferedReader br=null;
                try {
                        br=new BufferedReader(new FileReader("UserName.txt"));
                } catch (Exception e) {                     
                }
                String name=null;
                try {
                        name=sbr.readLine();                              
                } catch (Exception e) {
                        throw new RuntimeException("输入流读取出现问题1");
                }        
                //if(name==null)
                //break;
                String line=null;               
                boolean flag=false;
                try {
                        while((line=br.readLine())!=null) {               
                                System.out.println(line);
                                if(line.equals(name)) {                                                        
                                        flag=true;
                                        break;
                                }                        
                        }
                } catch (Exception e) {
                        throw new RuntimeException("输入流读取出现问题2");
                }
                if(flag) {
                        System.out.println(name+"登陆成功");
                        spw.println("登陆成功--欢迎" + name);
                        break;
                } else {
                        System.out.println(name+"尝试登陆");
                        spw.println(name+"登陆失败");
                }
                try {
                        br.close();
                } catch (Exception e) {
                        throw new RuntimeException("关闭异常1");
                }              
        }            
        try {
                s.close();
        } catch (Exception e) {
                throw new RuntimeException("关闭异常2");
        }
        }
}