JAVA如何实现心跳检测(java,开发技术)

1、心跳机制简介

在分布式系统中，分布在不同主机上的节点需要检测其他节点的状态，如服务器节点需要检测从节点是否失效。为了检测对方节点的有效性，每隔固定时间就发送一个固定信息给对方，对方回复一个固定信息，如果长时间没有收到对方的回复，则断开与对方的连接。

发包方既可以是服务端，也可以是客户端，这要看具体实现。因为是每隔固定时间发送一次，类似心跳，所以发送的固定信息称为心跳包。心跳包一般为比较小的包，可根据具体实现。心跳包主要应用于长连接的保持与短线链接。

一般而言，应该客户端主动向服务器发送心跳包，因为服务器向客户端发送心跳包会影响服务器的性能。

实现原理：长连接的维持，是要客户端程序，定时向服务端程序，发送一个维持连接包的。如果，长时间未发送维持连接包，服务端程序将断开连接。

2、心跳机制实现方式

心跳机制有两种实现方式，一种基于TCP自带的心跳包，TCP的SO_KEEPALIVE选项可以，系统默认的默认跳帧频率为2小时，超过2小时后，本地的TCP 实现会发送一个数据包给远程的 Socket. 如果远程Socket 没有发回响应, TCP实现就会持续尝试 11 分钟, 直到接收到响应为止。 否则就会自动断开Socket连接。但TCP自带的心跳包无法检测比较敏感地知道对方的状态，默认2小时的空闲时间，对于大多数的应用而言太长了。可以手工开启KeepAlive功能并设置合理的KeepAlive参数。

另一种在应用层自己进行实现，基本步骤如下：

1、Client使用定时器，不断发送心跳；

2、Server收到心跳后，回复一个包；

3、Server为每个Client启动超时定时器，如果在指定时间内没有收到Client的心跳包，则Client失效。

3、客户端

Client通过持有Socket的对象，可以随时（使用sendObject方法）发送Massage Object(消息)给服务端。

如果keepAliveDelay毫秒（程序中是2秒）内未发送任何数据，则自动发送一个KeepAlive Object(心跳)给服务端，用于维持连接。

由于，我们向服务端，可以发送很多不同的消息对象，服务端也可以返回不同的对象。所以，对于返回对象的处理，要编写具体的ObjectAction实现类进行处理。通过Client.addActionMap方法进行添加。这样，程序会回调处理

4 、服务端

由于客户端会定时（keepAliveDelay毫秒）发送维持连接的信息过来，所以，服务端要有一个检测机制。

即当服务端receiveTimeDelay毫秒（程序中是3秒）内未接收任何数据，则自动断开与客户端的连接。

ActionMapping的原理与客户端相似（相同）。

通过添加相应的ObjectAction实现类，可以实现不同对象的响应、应答过程。

5、代码实现

5.1 KeepAlive.java

packagecom.zyz.mynative.demo02;/***@authorzyz*@version1.0*@data2023/2/1511:05*@Description:*/importjava.io.Serializable;importjava.text.SimpleDateFormat;importjava.util.Date;/****维持连接的消息对象（心跳对象）*@authorzyz*@version1.0*@data2023/2/1511:05*@Description:*/publicclassKeepAliveimplementsSerializable{privatestaticfinallongserialVersionUID=-2813120366138988480L;/*覆盖该方法，仅用于测试使用。*@seejava.lang.Object#toString()*/@OverridepublicStringtoString(){returnnewSimpleDateFormat("yyyy-MM-ddHH:mm:ss").format(newDate())+"\t维持连接包";}}

5.2 MyClient.java

packagecom.zyz.mynative.demo02;/***@authorzyz*@version1.0*@data2023/2/1511:06*@Description:*/importjava.io.IOException;importjava.io.InputStream;importjava.io.ObjectInputStream;importjava.io.ObjectOutputStream;importjava.net.Socket;importjava.net.UnknownHostException;importjava.util.concurrent.ConcurrentHashMap;/***C/S架构的客户端对象，持有该对象，可以随时向服务端发送消息。**@authorzyz*@version1.0*@data2023/2/1511:06*@Description:*/publicclassMyClient{/***处理服务端发回的对象，可实现该接口。*/publicstaticinterfaceObjectAction{voiddoAction(Objectobj,MyClientclient);}publicstaticfinalclassDefaultObjectActionimplementsObjectAction{@OverridepublicvoiddoAction(Objectobj,MyClientclient){System.out.println("处理：\t"+obj.toString());}}privateStringserverIp;privateintport;privateSocketsocket;//连接状态privatebooleanrunning=false;/***最后一次发送数据的时间*/privatelonglastSendTime;/***用于保存接收消息对象类型及该类型消息处理的对象*/privateConcurrentHashMap<Class,ObjectAction>actionMapping=newConcurrentHashMap<Class,ObjectAction>();publicMyClient(StringserverIp,intport){this.serverIp=serverIp;this.port=port;}publicvoidstart()throwsUnknownHostException,IOException{if(running){return;}socket=newSocket(serverIp,port);System.out.println("本地端口："+socket.getLocalPort());lastSendTime=System.currentTimeMillis();running=true;//保持长连接的线程，每隔2秒项服务器发一个一个保持连接的心跳消息newThread(newKeepAliveWatchDog()).start();//接受消息的线程，处理消息newThread(newReceiveWatchDog()).start();}publicvoidstop(){if(running){running=false;};}/***添加接收对象的处理对象。**@paramcls待处理的对象，其所属的类。*@paramaction处理过程对象。*/publicvoidaddActionMap(Class<Object>cls,ObjectActionaction){actionMapping.put(cls,action);}publicvoidsendObject(Objectobj)throwsIOException{ObjectOutputStreamoos=newObjectOutputStream(socket.getOutputStream());oos.writeObject(obj);System.out.println("发送：\t"+obj);oos.flush();}classKeepAliveWatchDogimplementsRunnable{longcheckDelay=10;//两秒钟检测一次longkeepAliveDelay=2000;@Overridepublicvoidrun(){while(running){if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){try{MyClient.this.sendObject(newKeepAlive());}catch(IOExceptione){e.printStackTrace();MyClient.this.stop();}lastSendTime=System.currentTimeMillis();}else{try{Thread.sleep(checkDelay);}catch(InterruptedExceptione){e.printStackTrace();MyClient.this.stop();}}}}}classReceiveWatchDogimplementsRunnable{@Overridepublicvoidrun(){while(running){try{InputStreamin=socket.getInputStream();if(in.available()>0){ObjectInputStreamois=newObjectInputStream(in);Objectobj=ois.readObject();System.out.println("接收：\t"+obj);ObjectActionoa=actionMapping.get(obj.getClass());oa=oa==null?newDefaultObjectAction():oa;oa.doAction(obj,MyClient.this);}else{Thread.sleep(10);}}catch(Exceptione){e.printStackTrace();MyClient.this.stop();}}}}publicstaticvoidmain(String[]args)throwsUnknownHostException,IOException{StringserverIp="127.0.0.1";intport=65432;MyClientclient=newMyClient(serverIp,port);client.start();}}

5.3 MyServer

packagecom.zyz.mynative.demo02;importjava.io.IOException;importjava.io.InputStream;importjava.io.ObjectInputStream;importjava.io.ObjectOutputStream;importjava.net.ServerSocket;importjava.net.Socket;importjava.util.concurrent.ConcurrentHashMap;/***C/S架构的服务端对象。**@authorzyz*@version1.0*@data2023/2/1511:08*@Description:*/publicclassMyServer{/***要处理客户端发来的对象，并返回一个对象，可实现该接口。*/publicinterfaceObjectAction{ObjectdoAction(Objectrev,MyServerserver);}publicstaticfinalclassDefaultObjectActionimplementsObjectAction{@OverridepublicObjectdoAction(Objectrev,MyServerserver){System.out.println("处理并返回："+rev);returnrev;}}privateintport;privatevolatilebooleanrunning=false;privatelongreceiveTimeDelay=3000;/***ConcurrentHashMap是线程安全的，ConcurrentHashMap并非锁住整个方法，*而是通过原子操作和局部加锁的方法保证了多线程的线程安全，且尽可能减少了性能损耗。*/privateConcurrentHashMap<Class,ObjectAction>actionMapping=newConcurrentHashMap<Class,ObjectAction>();privateThreadconnWatchDog;publicMyServer(intport){this.port=port;}/***通过继承Runnable,开启线程*/publicvoidstart(){if(running){return;};running=true;connWatchDog=newThread(newConnWatchDog());connWatchDog.start();}@SuppressWarnings("deprecation")publicvoidstop(){if(running){running=false;};if(connWatchDog!=null){connWatchDog.stop();};}publicvoidaddActionMap(Class<Object>cls,ObjectActionaction){actionMapping.put(cls,action);}/***继承Runnable重写run方法、实现线程*/classConnWatchDogimplementsRunnable{@Overridepublicvoidrun(){try{ServerSocketss=newServerSocket(port,5);while(running){Sockets=ss.accept();newThread(newSocketAction(s)).start();}}catch(IOExceptione){e.printStackTrace();MyServer.this.stop();}}}/***继承Runnable重写run方法、实现线程，通过匿名内部类*/classSocketActionimplementsRunnable{Sockets;booleanrun=true;longlastReceiveTime=System.currentTimeMillis();publicSocketAction(Sockets){this.s=s;}@Overridepublicvoidrun(){while(running&&run){if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){overThis();}else{try{InputStreamin=s.getInputStream();if(in.available()>0){ObjectInputStreamois=newObjectInputStream(in);Objectobj=ois.readObject();lastReceiveTime=System.currentTimeMillis();System.out.println("接收：\t"+obj);ObjectActionoa=actionMapping.get(obj.getClass());oa=oa==null?newDefaultObjectAction():oa;Objectout=oa.doAction(obj,MyServer.this);if(out!=null){ObjectOutputStreamoos=newObjectOutputStream(s.getOutputStream());oos.writeObject(out);oos.flush();}}else{Thread.sleep(10);}}catch(Exceptione){e.printStackTrace();overThis();}}}}privatevoidoverThis(){if(run){run=false;};if(s!=null){try{s.close();}catch(IOExceptione){e.printStackTrace();}}System.out.println("关闭："+s.getRemoteSocketAddress());}}publicstaticvoidmain(String[]args){intport=65432;MyServerserver=newMyServer(port);server.start();}}

5.4 测试结果

先开启服务端，在开启客户端