python socket

import socket
import threading
import sys
import time


class TCPClientTest:
    """TCP客户端 - 适配多客户端服务器，支持发送1/2/3指令并接收响应"""

    def __init__(self, host="127.0.0.1", port=8888):
        self.client_socket = None
        self.host = host
        self.port = port
        self.is_connected = False  # 连接状态标记
        self.recv_thread = None  # 接收响应的线程

    def connect_to_server(self):
        """连接到TCP服务器"""
        try:
            # 创建客户端套接字
            self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            # 设置超时（避免连接卡住）
            self.client_socket.settimeout(10)
            # 连接服务器
            self.client_socket.connect((self.host, self.port))
            self.is_connected = True
            print(f"[客户端] 成功连接到服务器 {self.host}:{self.port}")

            # 启动接收响应的线程（后台持续接收服务器消息）
            self.recv_thread = threading.Thread(target=self.receive_messages, daemon=True)
            self.recv_thread.start()

            return True
        except socket.timeout:
            print(f"[客户端] 连接超时 - 服务器 {self.host}:{self.port} 未响应")
            return False
        except ConnectionRefusedError:
            print(f"[客户端] 连接失败 - 服务器 {self.host}:{self.port} 未启动或拒绝连接")
            return False
        except Exception as e:
            print(f"[客户端] 连接异常: {str(e)}")
            return False

    def receive_messages(self):
        """后台接收服务器响应的线程"""
        print("[接收线程] 已启动，等待服务器消息...")
        while self.is_connected:
            try:
                # 接收服务器数据（缓冲区1024字节）
                recv_data = self.client_socket.recv(1024).decode('utf-8').strip()
                if not recv_data:
                    print("[客户端] 服务器主动断开连接")
                    self.is_connected = False
                    break
                # 打印服务器响应
                print(f"\n[服务器响应] {recv_data}")
                print("根据接收到数据，do something")
                self.recvdata = recv_data
            except socket.timeout:
                continue  # 超时继续等待
            except Exception as e:
                if self.is_connected:
                    print(f"\n[接收异常] {str(e)}")
                break

    def send_command(self, command):
        """发送指令到服务器"""
        if not self.is_connected or self.client_socket is None:
            print("[发送失败] 未连接到服务器")
            return False

        try:
            # 编码并发送指令
            self.client_socket.sendall(command.encode('utf-8'))
            print(f"\n[发送成功] 指令: {command}")
            return True
        except BrokenPipeError:
            print("[发送失败] 连接已断开（Broken Pipe）")
            self.is_connected = False
            return False
        except Exception as e:
            print(f"[发送异常] {str(e)}")
            self.is_connected = False
            return False

    def disconnect(self):
        """断开与服务器的连接"""
        self.is_connected = False
        if self.client_socket:
            try:
                self.client_socket.close()
                print("[客户端] 已断开与服务器的连接")
            except Exception as e:
                print(f"[关闭异常] {str(e)}")


def main():
    # 创建客户端实例（可修改host/port适配你的服务器）
    client = TCPClientTest(host="127.0.0.1", port=8888)

    # 连接服务器
    if not client.connect_to_server():
        sys.exit(1)

    # 交互输入指令
    print("\n=== 客户端操作说明 ===")
    print("输入 1/2/3 发送对应指令到服务器")
    print("输入 quit 退出客户端")
    print("======================\n")

    try:
        while client.is_connected:
            # 手动输入指令
            command = input("请输入指令(1/2/3)或输入quit退出: ").strip()

            # 退出逻辑
            if command.lower() == "quit":
                client.disconnect()
                break

            client.send_command(command)


    except KeyboardInterrupt:
        print("\n\n[用户操作] 检测到Ctrl+C，正在退出...")
        client.disconnect()
    except Exception as e:
        print(f"\n[客户端异常] {str(e)}")
        client.disconnect()


if __name__ == "__main__":
    main()

import socket
import threading
import time
import uuid


class TCPServerTest:
    """TCP服务器测试类 - 支持多客户端并发，接1发送get 1，仅Ctrl+C关闭"""
    def __init__(self):
        self.server_socket = None
        self.is_server_running = False  # 服务器总运行标记
        self.clients = {}  # 客户端连接池: {client_id: (client_socket, address, thread)}
        self.clients_lock = threading.Lock()  # 保护客户端连接池的线程锁
        self.recv_data = {}  # 每个客户端的接收缓冲区: {client_id: data_str}
        self.recv_data_lock = threading.Lock()  # 保护接收缓冲区的锁
        self.HOST = "127.0.0.1"
        self.PORT = 8888
        self.BUFFER_SIZE = 1024

    def is_socket_valid(self, sock):
        """检查套接字有效性"""
        if sock is None:
            return False
        try:
            return sock.fileno() != -1
        except (OSError, AttributeError):
            return False

    def handle_client(self, client_socket, address, client_id):
        """处理单个客户端的通信（独立线程）"""
        print(f"[客户端{client_id}] 已连接 - 地址: {address[0]}:{address[1]}")
        # 连接成功立即返回OK
        self.send_message(client_id, "OK")
        while self.is_server_running:
            try:
                if not self.is_socket_valid(client_socket):
                    break

                # 接收客户端数据
                recv_data = client_socket.recv(self.BUFFER_SIZE).decode('utf-8').strip()
                if not recv_data:  # 客户端主动断开
                    print(f"[客户端{client_id}] 主动断开连接")
                    break

                # 存储接收到的数据到对应客户端的缓冲区
                with self.recv_data_lock:
                    if client_id not in self.recv_data:
                        self.recv_data[client_id] = ""
                    self.recv_data[client_id] += recv_data
                    print(f"[客户端{client_id}] 收到数据: {recv_data} | 累计: {self.recv_data[client_id]}")
            except Exception as e:
                print(f"[客户端{client_id}] 通信异常: {str(e)}")
                break

        # 客户端断开，清理资源
        with self.clients_lock:
            if client_id in self.clients:
                del self.clients[client_id]
        with self.recv_data_lock:
            if client_id in self.recv_data:
                del self.recv_data[client_id]

        client_socket.close()
        print(f"[客户端{client_id}] 连接已清理 | 当前在线客户端数: {len(self.clients)}")

    def send_message(self, client_id, send_data):
        """向指定客户端发送数据"""
        with self.clients_lock:
            if client_id not in self.clients:
                print(f"[发送失败] 客户端{client_id}不存在")
                return -1

            client_socket, _, _ = self.clients[client_id]

        if not self.is_socket_valid(client_socket):
            print(f"[发送失败] 客户端{client_id}套接字无效")
            return -1

        try:
            data_bytes = send_data.encode("utf-8")
            client_socket.sendall(data_bytes)
            print(f"[客户端{client_id}] 发送成功: {send_data}")
            return 1
        except Exception as e:
            print(f"[客户端{client_id}] 发送失败: {str(e)}")
            return -1

    def broadcast_message(self, send_data):
        """广播消息给所有在线客户端"""
        with self.clients_lock:
            online_clients = list(self.clients.keys())

        for client_id in online_clients:
            self.send_message(client_id, send_data)
        print(f"[广播] 已发送: {send_data} | 覆盖客户端数: {len(online_clients)}")

    def start_server(self):
        """启动服务器，持续监听多客户端连接"""
        try:
            # 创建服务器套接字
            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
            self.server_socket.bind((self.HOST, self.PORT))
            self.server_socket.listen(10)  # 增大监听队列，支持更多并发连接
            self.is_server_running = True

            print(f"[服务器启动成功] 监听 {self.HOST}:{self.PORT}")
            print(f"[核心特性] 多客户端并发 | 接收到1立即发送get 1 | 按 Ctrl+C 关闭服务器\n")

            # 持续接受新客户端连接
            while self.is_server_running:
                try:
                    client_socket, address = self.server_socket.accept()
                    client_id = str(uuid.uuid4())[:8]  # 生成短UUID作为客户端ID

                    # 创建客户端处理线程
                    client_thread = threading.Thread(
                        target=self.handle_client,
                        args=(client_socket, address, client_id),
                        daemon=True
                    )
                    client_thread.start()

                    # 将客户端信息加入连接池
                    with self.clients_lock:
                        self.clients[client_id] = (client_socket, address, client_thread)

                    print(f"[新客户端] ID:{client_id} | 当前在线客户端数: {len(self.clients)}")

                except Exception as e:
                    if self.is_server_running:
                        print(f"[接受连接异常] {str(e)}，1秒后重试...")
                        time.sleep(1)

        except Exception as e:
            print(f"[服务器启动失败] {str(e)}")
            self.is_server_running = False
        finally:
            # 关闭服务器时清理所有客户端连接
            self.stop_server()

    def stop_server(self):
        """关闭服务器，清理所有资源"""
        self.is_server_running = False

        # 关闭所有客户端连接
        with self.clients_lock:
            for client_id in list(self.clients.keys()):
                client_socket, _, _ = self.clients[client_id]
                if self.is_socket_valid(client_socket):
                    client_socket.close()
                del self.clients[client_id]

        # 关闭服务器套接字
        if self.is_socket_valid(self.server_socket):
            self.server_socket.close()

        print("[服务器] 已关闭，所有客户端连接已清理")

    def process_client_commands(self):
        """处理客户端指令（核心修改：接1发送get 1），独立线程运行"""
        print("in process_client_commands")

        while self.is_server_running:
            time.sleep(0.1)  # 降低轮询频率，减少资源占用
            with self.recv_data_lock:
                # 遍历所有客户端的接收缓冲区
                for client_id in list(self.recv_data.keys()):
                    data = self.recv_data[client_id]
                    if not data:
                        continue

                    # 核心修改：接收到1，立即发送get 1给对应客户端
                    if "1" == data:
                        print(f"[客户端{client_id}] 检测到指令1，执行响应")
                        self.send_message(client_id, "1 do operator")

                    # 保留2/3指令处理（如需修改可直接改响应内容，格式同上面）
                    if "2" == data:
                        print(f"[客户端{client_id}] 检测到指令2，执行响应")
                        self.send_message(client_id, "2 do operator")

                    if "3" == data:
                        print(f"[客户端{client_id}] 检测到指令3，执行响应")
                        self.send_message(client_id, "3 do operator")

                    self.recv_data[client_id] = ""



if __name__ == "__main__":
    # 实例化服务器
    server = TCPServerTest()

    # 启动服务器主线程（监听客户端连接）
    server_thread = threading.Thread(target=server.start_server, daemon=True)
    server_thread.start()
    time.sleep(2)

    # 测试：启动指令处理线程（核心：接1发get 1）
    # cmd_thread = threading.Thread(target=server.process_client_commands, daemon=True)
    # cmd_thread.start()
    server.process_client_commands()
    # 主线程永久阻塞，仅Ctrl+C退出
    # try:
    #     while True:
    #         time.sleep(1)
    #         # 可选：打印当前在线客户端数（取消注释即可）
    #         # with server.clients_lock:
    #         #     print(f"\r[当前在线] {len(server.clients)} 个客户端", end="")
    # except KeyboardInterrupt:
    #     print("\n\n[用户操作] 检测到Ctrl+C，正在关闭服务器...")
    #     server.stop_server()
    #     time.sleep(1)
    #     print("[服务器] 已完全关闭，程序退出")