一般是用来判断对方（设备，进程或其它网元）是否正常动行，一般采用定时发送简单的通讯包，如果在指定时间段内未收到对方响应，则判断对方已经当掉。用于检测TCP的异常断开。一般是用来判断对方（设备，进程或其它网元）是否正常动行，一般采用定时发送简单的通讯包，如果在指定时间段内未收到对方响应，则判断对方已经当掉。用于检测TCP的异常断开。基本原因是服务器端不能有效的判断客户端是否在线也就是说，服务器无法区分客户端是长时间在空闲，还是已经掉线的情况.所谓的心跳包就是客户端定时发送简单的信息给服务器端告诉它我还在而已。
...
客户端每隔一段时间发一个包，使用TCP的，用send发，使用UDP的，用sendto发，服务器收到后，就知道当前客户端还处于“活着”的状态，否则，如果隔一定时间未收到这样的包，则服务器认为客户端已经断开，进行相应的客户端断开逻辑处理。
1.心跳包实际就是一个自定义的协议包，主要用于判断对方机器是否还在连接。你可以自己定义协议的格式。
2.既然是协议，当然需要c/s双方都支持
3.如果你仅仅是为了判断服务器是否在线，用tcp协议自带的心跳包就可以了，用setsockopt设置socket的SO_KEEPALIVE属性，可以设置发包时间间隔
合理的解决方案就是做心跳处理，只是在客户端新开一个线程，然后while，里面sleep（5000）+向网络发送一个数据，也就是每五秒发送一个数据，这个数据最好跟正常的数据分开，简单些，然后在客户端设置socket.setSoTimeout(10000);，也就是说如果10秒钟没接收到数据的话就抛异常，这样就可以了。
[java] view plain copy
1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStream;
4. import java.io.InputStreamReader;
5. import java.net.InetSocketAddress;
6. import java.net.ServerSocket;
7. import java.net.Socket;
8. import java.util.Date;
9. import java.util.HashMap;
10. import java.util.Map;
11.
12. import org.dom4j.Document;
13. import org.dom4j.DocumentException;
14. import org.dom4j.DocumentHelper;
15.
16. import cn.edu.zju.cst.mina.im.server.entity.User;
17. import cn.edu.zju.cst.mina.im.server.handler.ServerControler;
18.
19. public class UserStateManage extends Thread {
20.
21. //在线用户状态列表
22. static HashMap<Integer, UserState> userStateList = new HashMap<Integer, UserState>();
23. new Object();
24.
25. //当前的连接数和工作线程数
26. static int workThreadNum = 0;
27. static int socketConnect = 0;
28.
29. private ServerSocket serverSocket;
30. //服务器IP
31. private String host = "10.82.81.79";
32.
33. //服务器端口
34. private int stateReportPort = 60001;
35.
36. //设置心跳包的结束标记
37. "</protocol>";
38. 0, 10);
39.
40. //扫描间隔
41. private int scanTime = 1800;
42.
43.
44. @Override
45. public void run() {
46. //绑定端口,并开始侦听用户的心跳包
47. serverSocket = startListenUserReport(stateReportPort);
48. if(serverSocket == null){
49. "【创建ServerSocket失败！】");
50. return;
51. }
52. //启动扫描线程
53. new Thread(new scan());
54. scanThread.start();
55. //等待用户心跳包请求
56. while(true){
57. null;
58. try {
59. 1;
60. //接收客户端的连接
61. socket = serverSocket.accept();
62. //为该连接创建一个工作线程
63. new Thread(new Handler(socket));
64. //启动工作线程
65. workThread.start();
66. catch (IOException e) {
67. e.printStackTrace();
68. }
69. }
70. }
71.
72. /**
73. * 创建一个ServerSocket来侦听用户心跳包请求
74. * @param port 指定的服务器端的端口
75. * @return 返回ServerSocket
76. * @author dream
77. */
78. public ServerSocket startListenUserReport(int port){
79. try {
80. new ServerSocket();
81. if(!serverSocket.getReuseAddress()){
82. true);
83. }
84. new InetSocketAddress(host,port));
85. "【开始在"+serverSocket.getLocalSocketAddress()+"上侦听用户的心跳包请求！】");
86. return serverSocket;
87. catch (IOException e) {
88. "【端口"+port+"已经被占用！】");
89. if (serverSocket != null) {
90. if (!serverSocket.isClosed()) {
91. try {
92. serverSocket.close();
93. catch (IOException e1) {
94. e1.printStackTrace();
95. }
96. }
97. }
98. }
99. return serverSocket;
100. }
101.
102.
103. //工作线程类
104. class Handler implements Runnable{
105. private Socket socket;
106. null;
107. null;
108. private int userId;
109. private int userState;
110. /**
111. * 构造函数，从调用者那里取得socket
112. * @param socket 指定的socket
113. * @author dream
114. */
115. public Handler(Socket socket){
116. this.socket = socket;
117. }
118.
119. /**
120. * 从指定的socket中得到输入流
121. * @param socket 指定的socket
122. * @return 返回BufferedReader
123. * @author dream
124. */
125. private BufferedReader getReader(Socket socket){
126. null;
127. null;
128.
129. try {
130. is = socket.getInputStream();
131. new BufferedReader(new InputStreamReader(is));
132. catch (IOException e) {
133. e.printStackTrace();
134. }
135. return br;
136. }
137.
138. public void run() {
139. try{
140. 1;
141. "【第"+workThreadNum+"个的连接:"+socket.getInetAddress()+":"+socket.getPort()+"】");
142. BufferedReader br = getReader(socket);
143. null;
144. new StringBuffer();
145. while ((meg = br.readLine()) != null) {
146. report.append(meg);
147. if (meg.contains(csEndFlag)) {
148. us = getReporterUserState(meg, socket);
149. synchronized (hashLock) {
150. userStateList.put(userId, us);
151. }
152. }
153. }
154. catch(IOException e){
155. "【客户:"+newUser.getUser_id()+"已经断开连接！】");
156. userStateList.remove( userId );
157. 1);
158. finally{
159. if(socket != null){
160. try {
161. //断开连接
162. socket.close();
163. catch (IOException e) {
164. e.printStackTrace();
165. }
166. }
167. }
168. }
169. private UserState getReporterUserState(String meg , Socket socket){
170. new UserState();
171. try {
172. Document requestDoc = DocumentHelper.parseText(meg);
173. newUser = ServerControler.parseXmlToUserState(requestDoc,socket);
174. userId = newUser.getUser_id();
175. userState = newUser.getUser_state();
176. 2);
177. us.setUser_state( userState );
178. us.setUser_id( userId );
179. us.setUser_ip(newUser.getUser_ip());
180. us.setUser_port(newUser.getUser_port());
181. catch (DocumentException e) {
182. "【来自客户端的信息不是一个合法的心跳包协议】");
183. }
184. return us;
185. }
186. }
187.
188. //扫描线程
189. class scan implements Runnable{
190. public void run() {
191. while (true) {
192. "*******"+new Date()+"：扫描线程开始扫描"+"*******");
193. synchronized (hashLock) {
194. if(!userStateList.isEmpty()){
195. //遍历在线用户列表
196. for (Map.Entry<Integer, UserState> entry : userStateList.entrySet()) {
197. int flag = entry.getValue().getFlag();
198. if ( (flag - 1) < 0) {
199. //在这里通知该用户的好友其状态发生改变
200. // announceStateChange(entry.getKey() , 0);
201. else{
202. 1);
203. userStateList.put(entry.getKey(), entry.getValue());
204. }
205. "-->" + entry.getValue().toString());
206. }
207. else{
208. "现在还没有在线用户！");
209. }
210. }
211. //实现定时扫描
212. try {
213. sleep(scanTime);
214. catch (InterruptedException e) {
215. e.printStackTrace();
216. }
217. }
218. }
219. }
220.
221. private void announceStateChange(int userId , int state){
222. "通知其好友!");
223. }
224.
225. /**
226. * 查询一个用户是否在线
227. * @param userId 指定要查询状态的用户的ID
228. * @return true 在线； false 不在线；
229. * @author dream
230. */
231. public boolean isAlive(int userId){
232. synchronized (hashLock) {
233. return userStateList.containsKey(userId);
234. }
235. }
236.
237. /**
238. * 返回指定用户ID的状态
239. * @param userId 指定要查询状态的用户的ID
240. * @return >0 该用户在线; -1 该用户离线
241. * @author dream
242. */
243. public int getUserState(int userId){
244. synchronized (hashLock) {
245. if(userStateList.containsKey(userId)){
246. return userStateList.get(userId).getUser_state();
247. else{
248. return -1;
249. }
250. }
251. }
252.
253. public Object getHashLock() {
254. return hashLock;
255. }
256.
257. public void setHashLock(Object hashLock) {
258. this.hashLock = hashLock;
259. }
260.
261. public String getHost() {
262. return host;
263. }
264.
265. public void setHost(String host) {
266. this.host = host;
267. }
268.
269. public int getStateReportPort() {
270. return stateReportPort;
271. }
272.
273. public void setStateReportPort(int stateReportPort) {
274. this.stateReportPort = stateReportPort;
275. }
276.
277. public String getEndFlag() {
278. return endFlag;
279. }
280.
281. public void setEndFlag(String endFlag) {
282. this.endFlag = endFlag;
283. }
284.
285. public int getScanTime() {
286. return scanTime;
287. }
288.
289. public void setScanTime(int scanTime) {
290. this.scanTime = scanTime;
291. }
292.
293. public static HashMap<Integer, UserState> getUserStateList() {
294. return userStateList;
295. }
296.
297. public static int getWorkThreadNum() {
298. return workThreadNum;
299. }
300.
301. public static int getSocketConnect() {
302. return socketConnect;
303. }
304. //测试本函数的main函数
305. public static void main(String arg[]){
306. new UserStateManage();
307. usm.start();
308. }
309. }本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
