JAVA实现心跳检测(长连接)
作者:菜鸟---程序员 发布时间:2022-12-16 04:26:30
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
package com.zyz.mynative.demo02;
/**
* @author zyz
* @version 1.0
* @data 2023/2/15 11:05
* @Description:
*/
import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
*
* 维持连接的消息对象(心跳对象)
* @author zyz
* @version 1.0
* @data 2023/2/15 11:05
* @Description:
*/
public class KeepAlive implements Serializable{
private static final long serialVersionUID = -2813120366138988480L;
/* 覆盖该方法,仅用于测试使用。
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"\t维持连接包";
}
}
5.2 MyClient.java
package com.zyz.mynative.demo02;
/**
* @author zyz
* @version 1.0
* @data 2023/2/15 11:06
* @Description:
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.ConcurrentHashMap;
/**
* C/S架构的客户端对象,持有该对象,可以随时向服务端发送消息。
*
* @author zyz
* @version 1.0
* @data 2023/2/15 11:06
* @Description:
*/
public class MyClient {
/**
* 处理服务端发回的对象,可实现该接口。
*/
public static interface ObjectAction {
void doAction(Object obj, MyClient client);
}
public static final class DefaultObjectAction implements ObjectAction {
@Override
public void doAction(Object obj, MyClient client) {
System.out.println("处理:\t" + obj.toString());
}
}
private String serverIp;
private int port;
private Socket socket;
//连接状态
private boolean running = false;
/**
* 最后一次发送数据的时间
*/
private long lastSendTime;
/**
* 用于保存接收消息对象类型及该类型消息处理的对象
*/
private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class, ObjectAction>();
public MyClient(String serverIp, int port) {
this.serverIp = serverIp;
this.port = port;
}
public void start() throws UnknownHostException, IOException {
if (running) {
return;
}
socket = new Socket(serverIp, port);
System.out.println("本地端口:" + socket.getLocalPort());
lastSendTime = System.currentTimeMillis();
running = true;
//保持长连接的线程,每隔2秒项服务器发一个一个保持连接的心跳消息
new Thread(new KeepAliveWatchDog()).start();
//接受消息的线程,处理消息
new Thread(new ReceiveWatchDog()).start();
}
public void stop() {
if (running) {
running = false;
}
;
}
/**
* 添加接收对象的处理对象。
*
* @param cls 待处理的对象,其所属的类。
* @param action 处理过程对象。
*/
public void addActionMap(Class<Object> cls, ObjectAction action) {
actionMapping.put(cls, action);
}
public void sendObject(Object obj) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(obj);
System.out.println("发送:\t" + obj);
oos.flush();
}
class KeepAliveWatchDog implements Runnable {
long checkDelay = 10;
//两秒钟检测一次
long keepAliveDelay = 2000;
@Override
public void run() {
while (running) {
if (System.currentTimeMillis() - lastSendTime > keepAliveDelay) {
try {
MyClient.this.sendObject(new KeepAlive());
} catch (IOException e) {
e.printStackTrace();
MyClient.this.stop();
}
lastSendTime = System.currentTimeMillis();
} else {
try {
Thread.sleep(checkDelay);
} catch (InterruptedException e) {
e.printStackTrace();
MyClient.this.stop();
}
}
}
}
}
class ReceiveWatchDog implements Runnable {
@Override
public void run() {
while (running) {
try {
InputStream in = socket.getInputStream();
if (in.available() > 0) {
ObjectInputStream ois = new ObjectInputStream(in);
Object obj = ois.readObject();
System.out.println("接收:\t" + obj);
ObjectAction oa = actionMapping.get(obj.getClass());
oa = oa == null ? new DefaultObjectAction() : oa;
oa.doAction(obj, MyClient.this);
} else {
Thread.sleep(10);
}
} catch (Exception e) {
e.printStackTrace();
MyClient.this.stop();
}
}
}
}
public static void main(String[] args) throws UnknownHostException, IOException {
String serverIp = "127.0.0.1";
int port = 65432;
MyClient client = new MyClient(serverIp, port);
client.start();
}
}
5.3 MyServer
package com.zyz.mynative.demo02;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;
/**
* C/S架构的服务端对象。
*
* @author zyz
* @version 1.0
* @data 2023/2/15 11:08
* @Description:
*/
public class MyServer {
/**
* 要处理客户端发来的对象,并返回一个对象,可实现该接口。
*/
public interface ObjectAction {
Object doAction(Object rev, MyServer server);
}
public static final class DefaultObjectAction implements ObjectAction {
@Override
public Object doAction(Object rev, MyServer server) {
System.out.println("处理并返回:" + rev);
return rev;
}
}
private int port;
private volatile boolean running = false;
private long receiveTimeDelay = 3000;
/**
* ConcurrentHashMap是线程安全的,ConcurrentHashMap并非锁住整个方法,
* 而是通过原子操作和局部加锁的方法保证了多线程的线程安全,且尽可能减少了性能损耗。
*/
private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class, ObjectAction>();
private Thread connWatchDog;
public MyServer(int port) {
this.port = port;
}
/**
* 通过继承Runnable ,开启线程
*/
public void start() {
if (running) {
return;
}
;
running = true;
connWatchDog = new Thread(new ConnWatchDog());
connWatchDog.start();
}
@SuppressWarnings("deprecation")
public void stop() {
if (running) {
running = false;
}
;
if (connWatchDog != null) {
connWatchDog.stop();
}
;
}
public void addActionMap(Class<Object> cls, ObjectAction action) {
actionMapping.put(cls, action);
}
/**
* 继承Runnable 重写run方法、实现线程
*/
class ConnWatchDog implements Runnable {
@Override
public void run() {
try {
ServerSocket ss = new ServerSocket(port, 5);
while (running) {
Socket s = ss.accept();
new Thread(new SocketAction(s)).start();
}
} catch (IOException e) {
e.printStackTrace();
MyServer.this.stop();
}
}
}
/**
* 继承Runnable 重写run方法、实现线程,通过匿名内部类
*/
class SocketAction implements Runnable {
Socket s;
boolean run = true;
long lastReceiveTime = System.currentTimeMillis();
public SocketAction(Socket s) {
this.s = s;
}
@Override
public void run() {
while (running && run) {
if (System.currentTimeMillis() - lastReceiveTime > receiveTimeDelay) {
overThis();
} else {
try {
InputStream in = s.getInputStream();
if (in.available() > 0) {
ObjectInputStream ois = new ObjectInputStream(in);
Object obj = ois.readObject();
lastReceiveTime = System.currentTimeMillis();
System.out.println("接收:\t" + obj);
ObjectAction oa = actionMapping.get(obj.getClass());
oa = oa == null ? new DefaultObjectAction() : oa;
Object out = oa.doAction(obj, MyServer.this);
if (out != null) {
ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
oos.writeObject(out);
oos.flush();
}
} else {
Thread.sleep(10);
}
} catch (Exception e) {
e.printStackTrace();
overThis();
}
}
}
}
private void overThis() {
if (run) {
run = false;
}
;
if (s != null) {
try {
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("关闭:" + s.getRemoteSocketAddress());
}
}
public static void main(String[] args) {
int port = 65432;
MyServer server = new MyServer(port);
server.start();
}
}
5.4 测试结果
先开启服务端,在开启客户端
参考资料:
1、java实现心跳机制
2、java实现长连接
来源:https://blog.csdn.net/weixin_43304253/article/details/129051919
猜你喜欢
- Spark_SQL的UDF使用用户自定义函数,也叫UDF,可以让我们使用Python/Java/Scala注册自定义函数,并在SQL中调用。
- C# XmlDocument操作XMLXML:Extensible Markup Language(可扩展标记语言)的缩写,是用来定义其它语
- 本文实例为大家分享了C#语言实现ini文件读写操作的具体代码,供大家参考,具体内容如下1、ini文件是什么?见百度百科2、C#语言实现ini
- 使用xml编写动态sql在Resources文件夹下创建一个Mapper文件夹比如我们需要在User表中使用增删改查,创建UserMappe
- 废话不多说了,直接给大家贴代码,具体代码如下所示://打开Excel文件,转换为DataTable DataTable dtExcel;pr
- 简介:gateway主要是做路由 负载,过滤 主要是替代zuul 1.x 性能比zuul好 zuul是基于Servlet ,gateway是
- 这篇文章主要介绍了Springboot2.0处理自定义异常并返回json,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考
- 前言《英文猜词游戏》代码行数没有超过200行,是之前为了背英语单词,特意研发的小游戏。主要设计1.事先准备单词文本。2.为了让玩家能与程序互
- 本文主要介绍我为桌面和 Web 设计的一个超级秘密 Flutter 项目使用了画布和可拖动节点界面。本教程将展示我如何使用堆栈来使用小部件完
- 第一步:下载需要添加的jar包可以在maven库中查找下载,也可以在对应官网下载maven库网址:https://mvnrepository
- Java中的多线程是一种抢占式的机制,而不是分时机制。抢占式的机制是有多个线程处于可运行状态,但是只有一个线程在运行。 共同点: 1. 他们
- Java 反射机制实例详解一、JAVA是动态语言吗?一般而言,说到动态言,都是指在程序运行时允许改变程序结构或者变量类型,从这个观点看,Ja
- c#中Math类的方法Math.Abs 已重载。 返回指定数字的绝对值。Math.Acos 返回余弦值为指定数字的角度。Math.Asin
- C# goto 语句用于直接在一个程序中转到程序中的标签指定的位置,标签实际上由标识符加上冒号构成。语法形式如下。goto Labell;
- 前言这几天看《Java并发编程之美》的时候又遇到了ThradLocal这个类,不得不说,这个类在平时很多场景都遇得到,所以对其进行一个系统性
- Java命令运行jar 报错运行jar命令java -jar xxx.jar报错:Caused by: java.lang.ClassNot
- 简介最近几年,各种新的高效序列化方式层出不穷,不断刷新序列化性能的上限,最典型的包括:专门针对Java语言的:Kryo,FST等等跨语言的:
- 1、#{}是预编译处理,MyBatis在处理#{ }时,它会将sql中的#{ }替换为?,然后调用PreparedStatement的set
- 本文实例为大家分享了Java解码H264格式视频流中的图片,供大家参考,具体内容如下引入依赖<dependency>  
- 1、数组数组的引用传递public class TestDemo1{public static void main(String args[