如何判断Socket连接失效

现在都搞升级，本人也也使用JDK6进行开发。在开发工程中对Socket进行管理时对于这个连接的超时和是否失效进行研究。结果网上的资料很是让人失望，可以说google和百度下来，前几页原创很少都是抄袭。

说正经的，对于连接超时和失效肯定会想到设置超时时间和判断连接是否可用。但是设置超时时间后起作用是在调用read方法的时候，如果只是设置了超时时间却没有调用read，那么就算服务端中断连接，客户端也是无法得知的。而且就算read异常，当前的连接仍然是有效的。

我们来看如下代码运行后再继续：

服务端：

Java代码   

1. package com.service;  
2. import java.net.*;  
3. /** 
4.  * @说明 从这里启动一个服务端监听某个端口 
5.  * @author 崔素强 
6.  */  
7. public class DstService {  
8.     public static void main(String[] args) {  
9.         try {             
10.             // 启动监听端口 8001  
11.             ServerSocket ss = new ServerSocket(8001);  
12.             // 没有连接这个方法就一直堵塞  
13.             Socket s = ss.accept();  
14.             // 将请求指定一个线程去执行  
15.             new Thread(new DstServiceImpl(s)).start();  
16.         } catch (Exception e) {  
17.             e.printStackTrace();  
18.         }  
19.     }  
20. }  

然后我们来看执行类，执行类在收到连接5秒后中断连接：

 

Java代码   

1. package com.service;  
2. import java.net.Socket;  
3. /** 
4.  * @说明 服务的具体执行类 
5.  * @author 崔素强 
6.  */  
7. public class DstServiceImpl implements Runnable {  
8.     Socket socket = null;  
9.     public DstServiceImpl(Socket s) {  
10.         this.socket = s;  
11.     }  
12.     public void run() {  
13.         try {  
14.             int index = 1;  
15.             while (true) {  
16.                 // 5秒后中断连接  
17.                 if (index > 5) {  
18.                     socket.close();  
19.                     System.out.println("服务端已经将连接关闭！");  
20.                     break;  
21.                 }  
22.                 index++;  
23.                 Thread.sleep(1 * 1000);  
24.             }  
25.         } catch (Exception e) {  
26.             e.printStackTrace();  
27.         }  
28.     }  
29. }  

我们在写一个客户端进行实验：

Java代码   

1. package com.client;  
2. import java.net.*;  
3. /** 
4.  * @说明 服务的客户端，会请求连接并实时打印连接对象的一些信息，但是不会进行流的操作 
5.  * @author 崔素强 
6.  */  
7. public class DstClient {  
8.     public static void main(String[] args) {  
9.         try {  
10.             Socket socket = new Socket("127.0.0.1", 8001);  
11.             socket.setKeepAlive(true);  
12.             socket.setSoTimeout(10);  
13.             while (true) {  
14.                 System.out.println(socket.isBound());  
15.                 System.out.println(socket.isClosed());  
16.                 System.out.println(socket.isConnected());  
17.                 System.out.println(socket.isInputShutdown());  
18.                 System.out.println(socket.isOutputShutdown());  
19.                 System.out.println("------------------------");  
20.                 Thread.sleep(3 * 1000);  
21.             }  
22.         } catch (Exception e) {  
23.             e.printStackTrace();  
24.         }  
25.     }  
26. }  

  

至于输出结果，虽然服务端已经中断连接，但是客户端一直输出下面内容：

Xml代码   

1. true  
2. false  
3. true  
4. false  
5. false  
6. ------------------------  

 从连接对象的属性信息来看，连接似乎没有中断。但实际虽然内存对象可用，但是物理连接已经失效。所以和网上其他抄袭来抄袭去的说法一样，靠连接对象属性来判断连接的可用性是不可行的。

大家会说那就判断调用read方法是否报错呗。我之前有文章已经讨论了关于调用网络里面流的一些内容，在没有判断这个流可用之前，我们是不会调用read方法的，当然具体你是怎么做的我不知道我在说我的情况！

读取网络数据流时的那个方法是这样的：

Java代码   

1. public static byte[] inputStreamToByte(InputStream inStream)  
2.         throws Exception {  
3.     int count = 0;  
4.     int haveCheck = 0;  
5.     // 如果在网络传输中数据没有完全传递，则方法返回0  
6.     while (count == 0) {  
7.         count = inStream.available();  
8.         haveCheck++;  
9.         if (haveCheck >= 50)  
10.             return null;  
11.     }  
12.     byte[] b = new byte[count];  
13.     inStream.read(b);  
14.     return b;  
15. }  

 就是说我们不会直接调用read方法，而available方法在流没有完整和网络中断时都会返回0，不会报错。

就是说就算你设置超时时间设置保持连接这些东西，只要你没有调用read的机会，你的程序就不会出问题。当然如果程序一直不调用read方法，那这个程序可真的够扯淡的了。

其实只要在使用这个连接的时候判断这个连接的可用性就行了，不要等着什么超时。

判断连接可用虽然网上一大片，其实就是那么回事，手动发送心跳包。

Java代码   

1. socket.sendUrgentData(0xFF); // 发送心跳包  

 乳沟你的连接已经中断，那么这个方法就会报错。

至于什么是心跳包，直接上理论吧。

心跳包就是在客户端和服务器间定时通知对方自己状态的一个自己定义的命令字，按照一定的时间间隔发送，类似于心跳，所以叫做心跳包。 用来判断对方（设备，进程或其它网元）是否正常运行，采用定时发送简单的通讯包，如果在指定时间段内未收到对方响应，则判断对方已经离线。用于检测TCP的异常断开。基本原因是服务器端不能有效的判断客户端是否在线，也就是说，服务器无法区分客户端是长时间在空闲，还是已经掉线的情况。所谓的心跳包就是客户端定时发送简单的信息给服务器端告诉它我还在而已。代码就是每隔几分钟发送一个固定信息给服务端，服务端收到后回复一个固定信息如果服务端几分钟内没有收到客户端信息则视客户端断开。 比如有些通信软件长时间不使用，要想知道它的状态是在线还是离线就需要心跳包，定时发包收包。发包方：可以是客户也可以是服务端，看哪边实现方便合理，一般是客户端。服务器也可以定时发心跳下去。一般来说，出于效率的考虑，是由客户端主动向服务器端发包，而不是服务器向客户端发。客户端每隔一段时间发一个包，使用TCP的，用send发，使用UDP的，用sendto发，服务器收到后，就知道当前客户端还处于“活着”的状态，否则，如果隔一定时间未收到这样的包，则服务器认为客户端已经断开，进行相应的客户端断开逻辑处理！

当然不能单纯理解心跳包就是往对方放松数据，因为心跳包是用于状态验证的，不是真实的数据。

我们来看如下例子，服务端不变：

Java代码   

1. package com.client;  
2. import java.net.*;  
3. /** 
4.  * @说明 服务的客户端，会请求连接并实时打印连接对象的一些信息，但是不会进行流的操作 
5.  * @author 崔素强 
6.  */  
7. public class DstClient {  
8.     public static void main(String[] args) {  
9.         try {  
10.             Socket socket = new Socket("127.0.0.1", 8001);  
11.             socket.setKeepAlive(true);  
12.             socket.setSoTimeout(10);  
13.             while (true) {  
14.                 socket.sendUrgentData(0xFF); // 发送心跳包  
15.                 System.out.println("目前是正常的！");  
16.                 Thread.sleep(3 * 1000);  
17.             }  
18.         } catch (Exception e) {  
19.             e.printStackTrace();  
20.         }  
21.     }  
22. }  

 看到控制台的输出：

Java代码   

1. 目前是正常的！  
2. 目前是正常的！  
3. java.net.SocketException: Invalid argument: send  
4.     at java.net.PlainSocketImpl.socketSendUrgentData(Native Method)  
5.     at java.net.PlainSocketImpl.sendUrgentData(PlainSocketImpl.java:550)  
6.     at java.net.Socket.sendUrgentData(Socket.java:928)  
7.     at com.client.DstClient.main(DstClient.java:14)  

 那就是说，只要你的服务端断了，调用方法就会出错！

至于我说的他不会作为可见的数据你可以更改服务端代码打印客户端内容，你会发现服务端不会将心跳包内容展示给你！

Java代码   

1. InputStream ips = socket.getInputStream();  
2. byte[] bt = inputStreamToByte(ips);  
3. if(null != bt)  
4.     System.out.println(new String(bt));  
5. else  
6.     System.out.println("Bt is null");  
7. System.out.println("****************************");  

 bt会一直是Null。为什么？因为我说的是对的！

哥通过示例说问题，也许不对有纰漏，但是咱绝对不去Copy，因为咱已经看厌了Copy！