python 在创建socket之后建立心跳机制

在Python中，建立心跳机制通常用于维持客户端和服务器之间的长连接，确保连接活跃性。心跳机制通常是通过定时发送心跳包（一种小型的、特定格式的数据包）来实现的，如果在预定时间内没有收到对方的心跳响应，则认为连接可能已经中断。

1.使用socket和threading模块实现的简单心跳机制示例

以下是一个使用socket和threading模块实现的简单心跳机制示例。示例分为服务器端和客户端两部分。服务器端会监听特定端口，客户端连接到服务器后，会定期发送心跳包。服务器接收到心跳包后，会发送响应确认包。

1.1 服务器端代码

登录后复制

import socket  
import threading  
  
def handle_client(conn, addr):  
    print(f"Connected by {addr}")  
    try:  
        while True:  
            data = conn.recv(1024)  
            if not data:  
                break  
            # 这里仅检查数据长度，实际可以检查更复杂的消息内容  
            if len(data) == 4 and data.decode() == 'ping':  
                print("Received ping, sending pong")  
                conn.sendall(b'pong')  
    finally:  
        conn.close()  
  
def start_server(host='127.0.0.1', port=12345):  
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:  
        s.bind((host, port))  
        s.listen()  
        print(f"Server is listening on {host}:{port}")  
        while True:  
            conn, addr = s.accept()  
            client_thread = threading.Thread(target=handle_client, args=(conn, addr))  
            client_thread.start()  
  
if __name__ == "__main__":  
    start_server()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.

1.2 客户端代码

登录后复制

import socket  
import time  
  
def send_heartbeat(sock):  
    while True:  
        try:  
            sock.sendall(b'ping')  
            response = sock.recv(1024)  
            if response == b'pong':  
                print("Received pong from server")  
            else:  
                print("Unexpected response from server:", response)  
            time.sleep(5)  # 每5秒发送一次心跳  
        except:  
            print("Failed to send heartbeat or receive response")  
            break  
  
def main():  
    host = '127.0.0.1'  
    port = 12345  
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:  
        s.connect((host, port))  
        heartbeat_thread = threading.Thread(target=send_heartbeat, args=(s,))  
        heartbeat_thread.start()  
          
        # 模拟其他操作  
        try:  
            while True:  
                time.sleep(1)  
        except KeyboardInterrupt:  
            print("Shutting down...")  
  
if __name__ == "__main__":  
    main()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.

1.3 说明

（1）服务器端：启动后监听12345端口，并接受客户端连接。每个连接由一个新线程处理，用于接收和响应心跳包。

（2）客户端：连接到服务器后，在一个单独的线程中发送心跳包（‘ping’），并等待服务器响应（‘pong’）。心跳发送间隔设置为5秒。

（3）心跳消息：为了简单起见，心跳消息仅为字符串’ping’和’pong’。在实际应用中，您可能需要更复杂的数据结构或协议来确保心跳包的正确性和完整性。

（4）异常处理：代码中加入了基本的异常处理逻辑，以便在出现网络问题时能够优雅地关闭连接或线程。

这个示例仅供学习和实验使用，并未考虑安全性、性能和可靠性方面的所有问题。在实际应用中，您可能需要更复杂的逻辑来处理这些方面。

2.实现心跳机制示例

在Python中实现心跳机制通常涉及在客户端和服务器之间定期发送和接收特定的小数据包（即心跳包）来确认连接的活跃性。下面我将提供一个简化的例子，展示如何在Python中使用socket编程和threading（或asyncio，对于异步编程）来实现心跳机制。

2.1 使用threading的同步心跳机制

2.1.1 服务器端

登录后复制

import socket  
import threading  
  
def handle_client(conn, addr):  
    print(f"Connected by {addr}")  
    try:  
        while True:  
            data = conn.recv(1024)  
            if not data:  
                break  
            if data.decode() == 'ping':  
                print("Received ping, sending pong")  
                conn.sendall(b'pong')  
    finally:  
        conn.close()  
  
def start_server(host='127.0.0.1', port=12345):  
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:  
        s.bind((host, port))  
        s.listen()  
        print(f"Server is listening on {host}:{port}")  
        while True:  
            conn, addr = s.accept()  
            client_thread = threading.Thread(target=handle_client, args=(conn, addr))  
            client_thread.start()  
  
if __name__ == "__main__":  
    start_server()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.

2.1.2 客户端

这里，我们添加了一个心跳发送函数，该函数将在一个单独的线程中运行，并定期发送心跳包。

登录后复制

import socket  
import threading  
import time  
  
def send_heartbeat(sock, interval=5):  
    while True:  
        try:  
            sock.sendall(b'ping')  
            response = sock.recv(1024)  
            if response == b'pong':  
                print("Received pong from server")  
            else:  
                print("Unexpected response from server:", response)  
            time.sleep(interval)  
        except Exception as e:  
            print(f"Failed to send heartbeat or receive response: {e}")  
            break  
  
def main():  
    host = '127.0.0.1'  
    port = 12345  
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:  
        s.connect((host, port))  
        heartbeat_thread = threading.Thread(target=send_heartbeat, args=(s,))  
        heartbeat_thread.start()  
          
        # 这里可以添加其他客户端逻辑  
        try:  
            while True:  
                time.sleep(1)  
        except KeyboardInterrupt:  
            print("Shutting down...")  
  
if __name__ == "__main__":  
    main()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.

2.2 使用asyncio的异步心跳机制

对于需要更高并发性和性能的应用，可以使用Python的asyncio库来实现异步心跳机制。

异步服务器端和客户端的实现将更为复杂，并且需要用到asyncio.StreamReader, asyncio.StreamWriter, asyncio.create_server 和 asyncio.sleep 等函数。

这里只提供一个概念性的框架：

• 使用asyncio.create_server创建异步服务器。
• 在服务器处理函数中，使用asyncio.StreamReader读取数据，asyncio.StreamWriter发送数据。
• 在客户端，使用asyncio.open_connection连接到服务器，并在异步函数中发送心跳包。
• 使用asyncio.sleep来控制心跳发送的时间间隔。

由于异步编程的复杂性，这里不展开完整的代码示例。如果你对asyncio感兴趣，建议深入学习其文档和教程。

2.3 注意

• 在实际应用中，心跳机制可能需要更复杂的错误处理和重连逻辑。
• 心跳包的内容和格式应根据应用需求进行设计。
• 心跳间隔应根据网络条件和应用需求进行调整。

3.使用threading的简化版Python代码示例

这里，将为您提供一个使用threading的简化版Python代码示例，该示例包含了客户端和服务器，它们通过心跳机制保持连接活跃。请注意，这个示例是为了教学目的而简化的，可能不包含生产环境中所需的所有错误处理和功能。

3.1 服务器端

登录后复制

import socket  
import threading  
  
def handle_client(conn, addr):  
    print(f"Connected by {addr}")  
    try:  
        while True:  
            data = conn.recv(1024)  
            if not data:  
                break  
            # 假设心跳包是简单的"ping"字符串  
            if data.decode().strip() == 'ping':  
                print("Received ping from client, sending pong...")  
                conn.sendall(b'pong')  
    finally:  
        conn.close()  
  
def start_server(host='127.0.0.1', port=12345):  
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server_socket:  
        server_socket.bind((host, port))  
        server_socket.listen()  
        print(f"Server is listening on {host}:{port}")  
        while True:  
            conn, addr = server_socket.accept()  
            client_thread = threading.Thread(target=handle_client, args=(conn, addr))  
            client_thread.start()  
  
if __name__ == "__main__":  
    start_server()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.

3.2 客户端

登录后复制

import socket  
import threading  
import time  
  
def send_heartbeat(sock, interval=5):  
    while True:  
        try:  
            sock.sendall(b'ping')  
            response = sock.recv(1024)  
            if response == b'pong':  
                print("Received pong from server")  
            else:  
                print("Unexpected response from server:", response)  
            time.sleep(interval)  
        except Exception as e:  
            print(f"Error sending heartbeat or receiving response: {e}")  
            break  
  
def main():  
    host = '127.0.0.1'  
    port = 12345  
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client_socket:  
        client_socket.connect((host, port))  
        print("Connected to server.")  
          
        heartbeat_thread = threading.Thread(target=send_heartbeat, args=(client_socket,))  
        heartbeat_thread.start()  
          
        try:  
            # 客户端主线程可以执行其他任务，这里仅作为示例，我们让主线程保持活动  
            while True:  
                time.sleep(1)  
        except KeyboardInterrupt:  
            print("Shutting down client...")  
            heartbeat_thread.join()  # 等待心跳线程结束  
  
if __name__ == "__main__":  
    main()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.

3.3 注意事项

（1）错误处理：在这个例子中，我添加了一些基本的错误处理来捕获发送心跳或接收响应时可能出现的异常。

（2）资源清理：服务器和客户端都使用了with语句来确保套接字在使用后被正确关闭。但是，由于心跳线程在main函数的外部作用域中运行，因此它可能会在main函数退出后继续运行。在实际情况中，您可能需要一种机制来优雅地关闭心跳线程。

（3）并发性：服务器使用线程来并发处理多个客户端连接。这意味着每个客户端都有自己的心跳发送和接收逻辑。

（4）心跳间隔：在这个例子中，心跳间隔被硬编码为5秒。在实际应用中，您可能需要根据网络条件和应用需求动态调整这个间隔。

（5）安全性：这个示例没有考虑安全性（如数据加密、身份验证等）。在生产环境中，这些都是非常重要的方面

原创作者: u_16777940 转载于: https://blog.51cto.com/u_16777940/11798315