溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“JAVA如何實現心跳檢測”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“JAVA如何實現心跳檢測”吧!
在分布式系統中，分布在不同主機上的節點需要檢測其他節點的狀態，如服務器節點需要檢測從節點是否失效。為了檢測對方節點的有效性，每隔固定時間就發送一個固定信息給對方，對方回復一個固定信息，如果長時間沒有收到對方的回復，則斷開與對方的連接。
發包方既可以是服務端，也可以是客戶端，這要看具體實現。因為是每隔固定時間發送一次，類似心跳，所以發送的固定信息稱為心跳包。心跳包一般為比較小的包，可根據具體實現。心跳包主要應用于長連接的保持與短線鏈接。
一般而言，應該客戶端主動向服務器發送心跳包，因為服務器向客戶端發送心跳包會影響服務器的性能。
實現原理：長連接的維持，是要客戶端程序，定時向服務端程序，發送一個維持連接包的。如果，長時間未發送維持連接包，服務端程序將斷開連接。
心跳機制有兩種實現方式，一種基于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失效。
Client通過持有Socket的對象，可以隨時（使用sendObject方法）發送Massage Object(消息)給服務端。
如果keepAliveDelay毫秒（程序中是2秒）內未發送任何數據，則自動發送一個KeepAlive Object(心跳)給服務端，用于維持連接。
由于，我們向服務端，可以發送很多不同的消息對象，服務端也可以返回不同的對象。所以，對于返回對象的處理，要編寫具體的ObjectAction實現類進行處理。通過Client.addActionMap方法進行添加。這樣，程序會回調處理
由于客戶端會定時（keepAliveDelay毫秒）發送維持連接的信息過來，所以，服務端要有一個檢測機制。
即當服務端receiveTimeDelay毫秒（程序中是3秒）內未接收任何數據，則自動斷開與客戶端的連接。
ActionMapping的原理與客戶端相似（相同）。
通過添加相應的ObjectAction實現類，可以實現不同對象的響應、應答過程。
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維持連接包";
}
}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();
}
}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();
}
}先開啟服務端，在開啟客戶端
到此，相信大家對“JAVA如何實現心跳檢測”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
