一个小demo：Socket 长连接（双向心跳、超时重试）

最新推荐文章于 2024-05-09 19:34:30 发布
最新推荐文章于 2024-05-09 19:34:30 发布
阅读量6.3k 收藏 10
点赞数 1
文章标签： socket 长连接 心跳
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45455623/article/details/99243718
版权

服务端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;

public class Server {

    /**
     * 客户端集合
     */
    private static List<Socket> clientList = new ArrayList<>();

    /**
     * 客户端心跳时间集合
     */
    private static Map<Socket, Date> heartbeatMap = new HashMap<>(16);

    /**
     * 心跳超时时间
     */
    private static final long TIMEOUT = 10 * 1000;

    /**
     * 服务端端口
     */
    private static final int PORT = 12345;

    /**
     * 以下为与客户端约定的指令，分别是：心跳、心跳回执、退出和退出回执
     */
    private static final String HEARTBEAT = "heartbeat";
    private static final String HEARTBEAT_RECEIPT = "heartbeat_receipt";
    private static final String EXIT = "exit";
    private static final String EXIT_RECEIPT = "exit_receipt";

    public static void main(String[] args) {
        new Server().start();
    }

    /**
     * 功能描述:
     * <服务端启动>
     *
     *
     * @return void
     * @author zhoulipu
     * @date   2019/8/8 15:52
     */
    private void start() {
        try {
            // 服务端开启
            ServerSocket server = new ServerSocket(PORT);
            System.out.println("服务端开启，等待客户端连接中...");
            // 循环监听客户端连接
            while (true) {
                // 等待客户端进行连接
                Socket client = server.accept();
                // 将客户端添加到集合
                clientList.add(client);
                System.out.println("有建立连接了，客户端地址：" + client.getRemoteSocketAddress().toString().replace("/", "") + "，当前连接数量：" + clientList.size());
                // 添加首次连接时间作为心跳
                heartbeatMap.put(client, new Date());
                // 开启新线程处理消息
                new MessageListener(client).start();
                // 开启新线程监测心跳
                new HeartbeatListener(client).start();
            }
        } catch (IOException e) {
            e.getStackTrace();
        }
    }

    /**
     * 消息处理
     */
    class MessageListener extends Thread {

        private Socket client;

        private MessageListener(Socket socket) {
            this.client = socket;
        }

        @Override
        public void run() {
            try {
                // 客户端连接后立即下发消息
                sendMsg(client, "连接已经建立，请开始消息传输");
                String msg;
                // 当心跳存在时，循环处理消息
                while (heartbeatMap.get(client) != null) {
                    // 读取客户端消息
                    msg = receiveMsg(client);
                    if (msg == null) {
                        // 表示连接已断开，等待心跳监听线程来处理
                        continue;
                    }
                    if (HEARTBEAT.equals(msg)) {
                        // 记录客户端的心跳时间
                        heartbeatMap.put(client, new Date());
                        // 发送回执消息
                        sendMsg(client, HEARTBEAT_RECEIPT);
                    } else if (EXIT.equals(msg)) {
                        // 客户端主动下线，删除连接和心跳
                        clientList.remove(client);
                        heartbeatMap.remove(client);
                        // 发送回执消息
                        sendMsg(client, EXIT_RECEIPT);
                        // 关闭连接
                        try {
                            client.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        System.out.println("有断开连接了，客户端地址：" + client.getRemoteSocketAddress().toString().replace("/", "") + "，当前连接数量：" + clientList.size());
                    } else {
                        System.out.println("[" + client.getPort() + "]:" + msg);
                        sendMsg(client, "我已接收信息\"" + msg + "\"");
                    }
                }
            } catch (IOException e) {
                e.getStackTrace();
            }
        }
    }

    /**
     * 心跳监测
     */
    class HeartbeatListener extends Thread {

        private Socket client;

        private HeartbeatListener(Socket socket) {
            this.client = socket;
        }

        @Override
        public void run() {
            Date time, now;
            // 当心跳存在时，循环处理消息
            while ((time = heartbeatMap.get(client)) != null) {
                now = new Date();
                // 比对当前时间和最新心跳时间
                if (now.getTime() - time.getTime() > TIMEOUT) {
                    // 客户端心跳超时（这里当作断开连接处理），删除连接和心跳
                    heartbeatMap.remove(client);
                    clientList.remove(client);
                    // 关闭连接
                    try {
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    System.out.println("有心跳超时了，客户端地址：" + client.getRemoteSocketAddress().toString().replace("/", "") + "，当前连接数量：" + clientList.size());
                }
            }
        }
    }

    /**
     * 功能描述:
     * <发送消息>
     *
     * @param socket 1
     * @param msg    2
     * @return void
     * @author zhoulipu
     * @date 2019/8/8 15:03
     */
    private void sendMsg(Socket socket, String msg) throws IOException {
        OutputStream out = socket.getOutputStream();
        PrintWriter writer = new PrintWriter(out);
        // 使用pw.write(msg); msg末尾必须加"\n"转义， println自动添加转义
        writer.println(msg);
        writer.flush();
    }

    /**
     * 功能描述:
     * <接受消息>
     *
     * @param socket 1
     * @return java.lang.String
     * @author zhoulipu
     * @date 2019/8/8 15:45
     */
    private String receiveMsg(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        return reader.readLine();
    }

}

客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.*;

public class Client {

    /**
     * 服务端地址
     */
    private static final String HOST = "127.0.0.1";

    /**
     * 服务端端口
     */
    private static final int PORT = 12345;

    /**
     * 心跳间隔时间（毫秒）
     */
    private static final long HEARTBEAT_INTERVAL = 2 * 1000;

    /**
     * 心跳超时时间（毫秒）
     */
    private static final long HEARTBEAT_TIMEOUT = 10 * 1000;

    /**
     * 以下为与客户端约定的指令，分别是：心跳、心跳回执和退出回执，退出由客户端触发
     */
    private static final String HEARTBEAT = "heartbeat";
    private static final String HEARTBEAT_RECEIPT = "heartbeat_receipt";
    private static final String EXIT_RECEIPT = "exit_receipt";

    /**
     * 连接通道，因为重连需要新建连接，所以存一个Map，保证新连接可以被共用
     */
    private static Map<String, Socket> socketMap = new HashMap<>(16);

    /**
     * 连接状态，因为重连需要新建连接，所以存一个Map，缓存共用
     */
    private static Map<String, Boolean> connectionStatusMap = new HashMap<>(16);

    /**
     * 心跳回执，因为重连需要新建连接，所以存一个Map，缓存共用
     */
    private static Map<String, Date> heartbeatReceiptTimeMap = new HashMap<>(16);

    /**
     * 连接重试，因为重连需要新建连接，所以存一个Map，缓存共用，null：正常连接，true：需要重新连接，false：不用重新连接
     */
    private static Map<String, Boolean> connectionRetryStatusMap = new HashMap<>(16);

    /**
     * 重试次数，因为重连需要新建连接，所以存一个Map，缓存共用
     */
    private static Map<String, Integer> connectionRetryCountMap = new HashMap<>();

    /**
     * 重试间隔
     */
    private static final long CONNECTION_RETRY_INTERVAL = 5 * 1000;


    public static void main(String[] args) {
        // 生成唯一key，保证连接重试后缓存共用
        String threadKey = UUID.randomUUID().toString();
        new Client().start(threadKey);
    }

    /**
     * 功能描述:
     * <客户端启动>
     *
     * @param  threadKey 1
     * @return void
     * @author zhoulipu
     * @date   2019/8/8 15:51
     */
    private void start(String threadKey) {
        try {
            // 客户端开启，建立连接
            Socket socket = new Socket(HOST, PORT);
            // 当连接建立成功，立即缓存（连接失败会抛异常，不会缓存）
            socketMap.put(threadKey, socket);
            // 添加首次连接时间作为心跳回执
            heartbeatReceiptTimeMap.put(threadKey, new Date());
            System.out.println("连接服务器成功，本机地址：" + socket.getLocalSocketAddress().toString().replace("/", ""));
            // 更新连接状态
            connectionStatusMap.put(threadKey, true);
            // 重置重试状态
            connectionRetryStatusMap.put(threadKey, null);
            // 重置重试次数
            connectionRetryCountMap.put(threadKey, 0);
            // 开启新线程处理消息
            new MessageListener(threadKey).start();
        } catch (IOException e) {
            e.getStackTrace();
        }
        // 开启新线程监听心跳
        new HeartbeatListener(threadKey).start();
        // 开启新线程连接重试
        new ConnectionRetryListener(threadKey).start();
    }

    /**
     * 消息处理
     */
    class MessageListener extends Thread {

        private String threadKey;

        private MessageListener(String threadKey) {
            this.threadKey = threadKey;
        }

        @Override
        public void run() {
            try {
                String msg;
                // 当连接正常时，循环处理消息
                while (connectionStatusMap.get(threadKey)) {
                    msg = receiveMsg(threadKey);
                    if (msg == null) {
                        // 表示连接已断开，等待心跳监听线程来处理
                        continue;
                    }
                    if (HEARTBEAT_RECEIPT.equals(msg)) {
                        // 收到心跳回执，记录时间
                        heartbeatReceiptTimeMap.put(threadKey, new Date());
                    } else if (EXIT_RECEIPT.equals(msg)) {
                        // 收到退出回执
                        // 设置重试状态，防止重新连接
                        connectionRetryStatusMap.put(threadKey, false);
                        System.out.println("[服务端]：我已收到关闭指令，连接已关闭");
                        // 关闭连接
                        try {
                            socketMap.get(threadKey).close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        // 关闭程序 System.exit(0)可以关闭调用此线程的其他方法，相当于连根拔除
                        System.exit(0);
                    } else {
                        System.out.println("[服务端]：" + msg);
                        // 开启消息处理线程，防止控制台无输入时导致心跳回执时间无法更新
                        new TaskHandler (threadKey).start();
                    }
                }
            } catch (IOException e) {
                e.getStackTrace();
            }
        }
    }

    /**
     * 消息处理
     */
    class TaskHandler extends Thread {

        private String threadKey;

        private TaskHandler (String threadKey) {
            this.threadKey = threadKey;
        }

        // 消息正常传输
        @Override
        public void run() {
            try {
                System.out.print("[客户端]：");
                // 这里有个问题，因为客户端从控制台获取信息，当一次连接失败时，如果没控制台信息输入，这个线程卡住。等重新连接后，再在控制台输入，会丢失一次消息。正常业务处理不会出现这种情况
                sendMsg(threadKey, new Scanner(System.in).nextLine());
            } catch (IOException e) {
                e.getStackTrace();
            }
        }

    }

    /**
     * 心跳监测
     */
    class HeartbeatListener extends Thread {

        private String threadKey;

        private HeartbeatListener(String threadKey) { this.threadKey = threadKey; }

        @Override
        public void run() {
            try {
                Date time, now;
                // 当心跳存在时，循环处理消息
                while ((time = heartbeatReceiptTimeMap.get(threadKey)) != null) {
                    now = new Date();
                    // 比对当前时间和最新心跳回执
                    if (now.getTime() - time.getTime() > HEARTBEAT_TIMEOUT) {
                        // 服务端心跳超时，更改连接状态和重试状态，关闭线程，等待重试
                        connectionStatusMap.put(threadKey, false);
                        connectionRetryStatusMap.put(threadKey, true);
                        // 关闭连接
                        try {
                            socketMap.get(threadKey).close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        return;
                    }
                    // 发送心跳
                    sendMsg(threadKey, HEARTBEAT);
                    // 心跳间隔
                    try {
                        Thread.sleep(HEARTBEAT_INTERVAL);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } catch (IOException e) {
                e.getStackTrace();
            }
        }
    }

    /**
     * 连接重试
     */
    class ConnectionRetryListener extends Thread {

        private String threadKey;

        private ConnectionRetryListener(String threadKey) { this.threadKey = threadKey; }

        @Override
        public void run() {
            // 连接正常或需要重连时循环监听
            while (connectionRetryStatusMap.get(threadKey) == null || connectionRetryStatusMap.get(threadKey)) {
                // 需要重连
                if (connectionRetryStatusMap.get(threadKey) != null) {
                    // 更新重连次数
                    connectionRetryCountMap.put(threadKey, connectionRetryCountMap.getOrDefault(threadKey, 0) + 1);
                    // 这个没什么用，我只是为了控制台打印好看
                    if (connectionRetryCountMap.get(threadKey) == 1) {
                        System.out.println();
                    }
                    System.out.println("连接已断开，正在尝试第" + connectionRetryCountMap.get(threadKey) + "次连接...");
                    // 重试间隔
                    try {
                        Thread.sleep(CONNECTION_RETRY_INTERVAL);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 连接重试
                    new Client().start(threadKey);
                    return;
                }
            }
        }
    }

    /**
     * 功能描述:
     * <发送消息>
     *
     * @param threadKey 1
     * @param msg       2
     * @return void
     * @author zhoulipu
     * @date 2019/8/8 15:45
     */
    private void sendMsg(String threadKey, String msg) throws IOException {
        OutputStream out = socketMap.get(threadKey).getOutputStream();
        PrintWriter writer = new PrintWriter(out);
        // 使用pw.write(msg); msg末尾必须加"\n"转义， println自动添加转义
        writer.println(msg);
        writer.flush();
    }

    /**
     * 功能描述:
     * <接受消息>
     *
     * @param threadKey 1
     * @return java.lang.String
     * @author zhoulipu
     * @date 2019/8/8 15:45
     */
    private String receiveMsg(String threadKey) throws IOException {
        InputStream in = socketMap.get(threadKey).getInputStream();
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        return reader.readLine();
    }

}
愚昧的取经人
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
socket 请求 超时重试
David的博客
08-04 1582
public class ZzSocketClientUtil {  public static String water_no = "";  static final Map MAPS = new HashMap();  // socket超时重试时间  static final int TIMEOUT = Constant.socketTimeOut;  static {   MA
socket长连接 demo
11-01
定制心跳对象,客户端心跳机制发送数据，保证连接，服务器延时检查，超时的断开连接，支持多客户端连接，并相应心跳对象
Socket长连接实现思路
一直在路上
04-19 6268
长连接的正确实现方式　　1、不关闭流实现长连接？　　　　流关闭了而不关闭Socket，还是无法达到长连接的效果的，所以，要长连接，流必须不能关闭！那么，是不是直接不关闭流，然后每次要发消息就直接往流里面任进去数据，然后调用flush()方法强制刷新就行了？其实不行的，这样客户端是无法正常接收信息的，你会发觉就算服务端flush了，客户端还是会一直在read方法那里阻塞！具体原因各位可以看一下java
安卓 socket通信原理 心跳机制 面试必备
最新发布
2401_83816970的博客
05-09 319
为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端- - 套接字的地址和端口号，然后就向服务器端套接字提出连接请求。 连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发 给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。SOCKET 连接与 TCP创建 Socket 连接时，可以指定使用的传输层协议，Socket 可以支持不同的
java-socket长连接demo体验
Java知音
07-18 3556
点击上方“Java知音”，选择“置顶公众号”技术文章第一时间送达！作者：DavidDinghttps://zhuanlan.zhihu.com/p/56135195推荐阅...
socket长连接demo
07-06
工作遇到的情况， 记录一个简单的保持长连接的方法，希望对自己对需要使用socket编程的童鞋有点用处。
java socket异步长连接demo
08-11
java异步长连接的demo 需要的童鞋可以参考下
Android Socket连接（心跳检测，断线重连，状态监测等）新资源包
07-02
Android Socket连接，包含心跳检测，断线重连，数据发送等等 博客地址：http://blog.csdn.net/yuzhiqiang_1993/article/details/78094909
Android的socket长连接（心跳检测）
12-18
- 这是客户端的实现，可能包括一个Activity或Service用于创建Socket连接，并设置心跳检测逻辑。 - 在客户端，也需要创建线程来处理Socket的读写操作，同时执行心跳检测的定时任务。 7. **注意事项** - Android中...
Socket长连接demo
08-23
Socket长连接是网络编程中的一个重要概念，特别是在设计高并发、实时性要求高的系统时，它被广泛应用。Socket，又称套接字，是网络通信的基本单位，提供了进程间、网络间进程通信的一种接口。本示例可能是一个关于...
一个简单的maven-socket连接demo
11-21
本示例是一个基于Maven构建的简单`Socket.IO`连接Demo，让我们深入探讨这个主题。 首先，`Maven`是一个项目管理工具，广泛用于Java开发。它帮助开发者管理和构建项目，通过依赖管理和项目生命周期管理，简化了项目...
论文研究-一种结合同步信息的双向心跳检测机制 .pdf
08-15
一种结合同步信息的双向心跳检测机制，许巡枝，别红霞，为保证分布式系统的可靠性，提高网络传输效率，在深入研究传统服务器心跳检测机制的基础上，结合集群系统中主控节点和普通节点需
C#使用Socket实现心跳的方法示例
08-25
主要介绍了C#使用Socket实现心跳的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SocketDemo:基于Socket实时通信的一个简单的demo
05-25
SocketDemo是一个基于Java Socket实现的实时通信示例项目。在Java编程中，Socket是网络通信的基础，它提供了进程间通信（IPC）的能力，允许两台机器上的应用程序通过网络进行数据交换。这个Demo主要展示了如何使用...
JAVA实现长连接(含心跳检测Demo)
08-25
在 Demo 中，我们定义了一个 KeepAlive 类，实现了 Serializable 接口，用于维持连接的消息对象（心跳对象）。在 Client 类中，我们实现了 ObjectAction 接口，用于处理服务端发回的对象。在 main 方法中，我们创建...
Socket通信完整实例(心跳包,客户端断线重连,服务端超时断开客户端连接)
choufen6202的博客
10-14 1051
通用工具类 public class SocketUtil { public static String ADDRESS = "192.168.1.123"; public static int PORT = 10086; /** * 读数...
Java 自测scoket server （长连接demo）
小调调Plus
04-29 232
@Component @Configuration //1.主要用于标记配置类，兼备Component的效果。 @EnableScheduling public class InitJob implements CommandLineRunner { @Override public void run(String... args) throws Exception {...
socket心跳超时检测，快速处理新思路（适用于超大量TCP连接情况下）
weixin_33720078的博客
11-14 256
2019独角兽企业重金招聘Python工程师标准>>> ...
Qt使用Keepalive机制实现断线重连
Fake瑞克的博客
09-24 2342
传输控制协议（TCP）存活包为可选特性，且默认关闭。存活包内没有数据。在以太网网络中，存活包的大小为最小长度的几帧（64字节）。存活时长（英语：Keepalive time）即空闲时，两次传输存活包的持续时间。TCP存活包时长可手动配置，默认不少于2个小时。存活间隔（英语：Keepalive interval）即未收到上个存活包时，两次连续传输存活包的时间间隔。存活重试次数（英语：Keepalive retry）即在判断远程主机不可用前的发送存活包次数。
socket连接,长连接demo编写
06-08
好的，下面是一个简单的 Python 长连接的示例代码： ```python import socket HOST = '127.0.0.1' # 服务器 IP 地址 PORT = 8888 # 服务器端口号 # 创建 socket 对象 s = socket.socket(socket.AF_INET, socket....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值