如何判断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！