Socket 长连接 短连接 心跳 JAVA SOCKET编程

简单解释就是：

短连接：建立连接，发送数据包，关闭连接

长连接：建立连接，发送数据包，发送心跳包，发送数据包，发送心跳包，发送心跳包。。。。。。

所以又频繁的数据收发的话，短连接会频繁创建TCP连接，而对于长连接，则始终用的是同一个TCP连接

[java] view plain copy print?

1. package com.tree.demo.socket;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.io.OutputStream;  
6. import java.net.ServerSocket;  
7. import java.net.Socket;  
8.   
9. public class ServerSocketDemo {  
10.   
11.     private static final int PORT = 1234;  
12.       
13.     private static final int BUFFER_SIZE = 1024;  
14.       
15.       
16.     public static void main(String[] args) {  
17.         // TODO Auto-generated method stub  
18.         try {  
19.             ServerSocket ss = new ServerSocket(PORT);  
20.             Socket s = ss.accept();  
21.             System.out.println("这是服务端，监听本机"+PORT+"端口");  
22.             byte[] recData = null;  
23.             InputStream in = s.getInputStream();  
24.             OutputStream out = s.getOutputStream();  
25.             while(true) {  
26.                 recData = new byte[BUFFER_SIZE];  
27.                 int r = in.read(recData);  
28.                 //int r = in.read(recData);  
29.                 if(r>-1) {  
30.                     String data = new String(recData);  
31.                     if(data.trim().equals("over")) {  
32.                         s.close();  
33.                     }  
34.                     System.out.println("读取到客户端发送的来数据："+data);  
35.                     out.write("这是服务端发给客户端的数据：".getBytes());  
36.                     out.write(recData);  
37.                 }else {  
38.                     System.out.println("数据读取完毕！");  
39.                     s.close();  
40.                     System.exit(0);  
41.                     //ss.close();  
42.                 }  
43.             }  
44.         } catch (IOException e) {  
45.             e.printStackTrace();  
46.         }  
47.     }  
48.   
49. }  

以上这种服务端读数据是阻塞式，如果客户端没有数据写过来，服务端就会一直阻塞在那不动

客户端开启一个telnet即可测试服务端的socket程序了，当然你也可以自己写一个socket客户端，如下：

[java] view plain copy print?

1. package socket;  
2.   
3. import java.io.IOException;  
4. import java.io.OutputStream;  
5. import java.net.Socket;  
6. import java.net.UnknownHostException;  
7.   
8. public class ClientSocketDemo {  
9.   
10.     private static final String HOST = "192.168.8.14";  
11.   
12.     private static final int PORT = 1234;  
13.   
14.     public static void main(String[] args) throws UnknownHostException,  
15.             IOException {  
16.         Socket client = new Socket(HOST, PORT);  
17.         OutputStream out = client.getOutputStream();  
18.         try {  
19.             while (true) {  
20.                 Thread.sleep(1000);  
21.                 System.out.println("发送心跳数据包");  
22.                 out.write("send heart beat data package !".getBytes());  
23.             }  
24.         } catch (Exception e) {  
25.             e.printStackTrace();  
26.             out.close();  
27.             client.close();  
28.         }  
29.     }  
30.   
31. }  

同时这要是一个心跳的实例，心跳只要不出现异常的情况下，可以直接使用client连接发送数据包，不需要new socket新建连接了。

accept()等待连接，该方法阻塞当前线程直到建立连接为止

以上服务端的网络程序只能和一个客户端程序连接，拒绝多个客户端的连接。

我们可以通过线程来解决这个问题：每当程序建立一个新的套接字连接，也就是调用accept方法时，将启动一个新的线程来处理服务器和客户端的连接，而主程序将立即返回并等待下一个连接。

具体内容请见：http://blog.csdn.net/simonchi/article/details/40785441