Python Socket编程实战：实现客户端与服务器双向数据通信
一、引言 (Introduction)
1. Socket编程的重要性
Socket作为网络通信的核心“端点”，是应用层与TCP/IP协议族之间的关键中间软件抽象层。它封装了复杂的网络底层细节（如TCP连接建立、数据分包与重组、差错校验等），让程序员无需深入理解协议栈原理，只需调用Socket接口即可实现跨设备数据交互，是构建网络应用的基础技术。
2. 应用场景
Socket的应用覆盖多个领域，典型场景包括：
- 即时通信类：聊天软件（如局域网聊天工具）、视频通话的底层数据传输
- 娱乐互动类：网络游戏（如多人联机游戏的玩家指令与状态同步）
- 远程控制类：远程桌面、服务器运维工具（如SSH的底层通信）
- 分布式与物联网：分布式系统节点间协作、物联网设备（如传感器）向云端传输数据
3. 本文目标与最终成果
本文将以“从零理解+实战实现”为核心，先拆解Socket通信的基本原理（如TCP Socket的连接流程、数据收发机制），再通过分步编码，带领读者完成一个基于Python的客户端-服务器程序开发。最终成果为：程序支持客户端与服务器双向稳定通信，可实现文本数据的实时发送与接收，且具备基础的连接异常处理能力，帮助读者掌握Socket编程的核心流程与实战技巧。
二、Socket编程基础 (Socket Fundamentals)
1. 什么是Socket？
Socket可通过“打电话”的生活场景通俗理解：
- IP地址相当于对方的“电话号码”，用于在互联网中定位目标设备；
- 端口号相当于设备上的“分机号”，用于区分设备内不同的网络应用（如80端口对应HTTP服务、22端口对应SSH服务）；
- Socket则是手中的“电话机”，整合了“电话号码+分机号”的通信能力，是应用程序与网络协议族交互的接口，通过它才能发起或接收网络连接。
2. TCP与UDP的核心区别
TCP和UDP是Socket编程中最常用的两种传输层协议，二者设计理念差异显著，可通过生活场景类比理解：
- TCP（传输控制协议）：类比“打电话”。需先拨号建立连接（三次握手），通话过程中能确认对方是否收到信息（确认应答机制），若信息丢失会重发（重传机制），且保证信息按发送顺序接收（排序机制）。核心特点是面向连接、可靠、有序，但建立连接和确认机制会增加开销，速度相对较慢。
- UDP（用户数据报协议）：类比“发短信”。无需提前建立连接，直接发送数据，不确认对方是否收到，也不保证数据顺序，若网络不稳定可能出现数据丢失或乱序。核心特点是无连接、不可靠、无序，但无需额外开销，速度快、延迟低。
TCP与UDP对比表格
| 对比维度 | TCP（传输控制协议） | UDP（用户数据报协议） |
| 连接方式 | 面向连接（需三次握手建立连接） | 无连接（直接发送，无需建立连接） |
| 数据可靠性 | 可靠（确认应答、重传、流量控制） | 不可靠（不确认、不重传） |
| 数据顺序 | 保证有序（按发送顺序接收） | 不保证有序（可能乱序） |
| 传输速度 | 较慢（需处理连接和确认机制） | 较快（无额外开销） |
| 数据边界 | 无边界（字节流，需应用层定义分隔） | 有边界（以数据报为单位，一次接收） |
| 应用场景 | 文件传输、网页浏览、即时聊天 | 视频直播、语音通话、网络游戏 |
3. Socket编程核心概念
- IP地址：设备在网络中的唯一标识，分为IPv4（如192.168.1.1）和IPv6（如2001:0db8:85a3:0000:0000:8a2e:0370:7334），用于定位网络中的目标设备。
- 端口号：范围为0-65535的整数，其中0-1023为系统保留端口（如80端口对应HTTP），1024-49151为注册端口，49152-65535为动态端口，用于区分设备内不同的网络应用。
- 协议（TCP/UDP）：规定了数据在网络中的传输规则，Socket需绑定具体协议，才能实现对应的通信逻辑（如TCP的可靠传输、UDP的高速传输）。
三、核心API与通信流程 (Core APIs & Communication Flow)
1. TCP Socket通信流程图
graph TD
A[服务器端 (Server)] --> B[创建套接字 socket()]
B --> C[绑定地址与端口 bind()]
C --> D[启动监听 listen()]
D --> E[等待并接受连接 accept()]
F[客户端 (Client)] --> G[创建套接字 socket()]
G --> H[向服务器发起连接 connect()]
H -->|连接请求| E
E --> I[生成新套接字（用于与该客户端通信）]
I --> J[收发数据 recv() / send()]
H --> K[收发数据 send() / recv()]
J --> L[关闭套接字 close()]
K --> L
2. 服务器端 (Server-Side) 核心函数
| 函数 | 功能说明 |
| socket() | 创建Socket对象，参数需指定地址族（如 AF_INET 代表IPv4）和协议类型（如 SOCK_STREAM 代表TCP），是通信的“基础工具”。 |
| bind() | 将创建的Socket与特定“地址+端口”绑定（如 ('127.0.0.1', 8080) ），确保客户端能通过该地址找到服务器。 |
| listen() | 让Socket进入“监听状态”，参数指定最大等待连接数（如 5 ），此时服务器开始等待客户端的连接请求。 |
| accept() | 阻塞等待客户端连接，连接成功后返回两个值：新的Socket对象（用于与该客户端单独通信）和客户端的“地址+端口”，原监听Socket仍继续等待其他连接。 |
| recv(size) | 通过 accept() 返回的新Socket接收客户端数据， size 指定每次最多接收的字节数（如 1024 ），返回接收到的字节流。 |
| send(data) | 通过新Socket向客户端发送数据，需先将字符串数据编码为字节流（如 data.encode('utf-8') ），返回实际发送的字节数。 |
| close() | 关闭Socket，释放网络资源，通常在通信结束后调用（需注意关闭“新Socket”和“监听Socket”）。 |
3. 客户端 (Client-Side) 核心函数
| 函数 | 功能说明 |
| socket() | 与服务器端 socket() 功能一致，创建客户端Socket对象，参数需与服务器端匹配（如 AF_INET + SOCK_STREAM ）。 |
| connect() | 主动向服务器发起连接，参数为服务器的“地址+端口”（如 ('127.0.0.1', 8080) ），连接失败会抛出异常。 |
| send(data) | 向服务器发送数据，需将字符串编码为字节流（如 'Hello Server'.encode('utf-8') ），通信阶段的核心发送接口。 |
| recv(size) | 接收服务器返回的数据， size 指定每次最大接收字节数（如 1024 ），返回服务器发送的字节流，需解码为字符串（如 data.decode('utf-8') ）。 |
| close() | 通信结束后关闭客户端Socket，释放资源，避免占用端口。 |
四、实战一：简单的单向通信示例 (Practice 1: Simple One-Way Communication)
本实战将实现客户端向服务器发送一条文本消息，服务器接收后打印的单向通信流程，采用 Python 内置 socket 模块开发，代码精简且标注清晰，便于理解核心步骤。
1. 服务器端代码（ server.py ）
服务器端需完成“创建Socket→绑定地址端口→监听→接受连接→接收数据”的完整流程，代码及分步讲解如下：
# 1. 导入socket模块（Python内置，无需额外安装）
import socket
# 2. 定义服务器配置信息
HOST = '127.0.0.1' # 服务器IP地址，127.0.0.1代表本机（仅本地可连接）
PORT = 8080 # 服务器端口号（需在1024-65535之间，避免与系统端口冲突）
# 3. 创建TCP Socket对象
# AF_INET：使用IPv4地址族；SOCK_STREAM：使用TCP协议（字节流）
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 4. 绑定Socket到指定的HOST和PORT
# 需将HOST和PORT组成元组传入，绑定失败会报错（如端口已被占用）
server_socket.bind((HOST, PORT))
# 5. 启动监听，等待客户端连接
# 参数5：最大等待连接数（即最多同时有5个客户端排队等待）
server_socket.listen(5)
print(f"服务器已启动，正在 {HOST}:{PORT} 等待客户端连接...")
# 6. 阻塞等待客户端连接（直到有客户端发起请求）
# accept()返回两个值：new_socket（与该客户端通信的专属Socket）、client_addr（客户端地址+端口）
new_socket, client_addr = server_socket.accept()
print(f"成功连接客户端：{client_addr}") # 打印客户端信息，如('127.0.0.1', 54321)
# 7. 接收客户端发送的数据
# recv(1024)：每次最多接收1024字节数据；返回值是字节流，需解码为字符串
recv_data = new_socket.recv(1024).decode('utf-8')
print(f"收到客户端消息：{recv_data}")
# 8. 关闭Socket，释放资源
new_socket.close() # 关闭与该客户端通信的专属Socket
server_socket.close() # 关闭服务器监听Socket
print("服务器已关闭连接")
2. 客户端代码（ client.py ）
客户端流程更简洁，只需“创建Socket→连接服务器→发送数据”，代码及分步：
# 1. 导入socket模块
import socket
# 2. 定义服务器地址（需与服务器端的HOST、PORT完全一致，否则无法连接）
SERVER_HOST = '127.0.0.1'
SERVER_PORT = 8080
# 3. 创建TCP Socket对象（参数与服务器端一致，保证协议匹配）
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 4. 向服务器发起连接请求
# 传入服务器的(HOST, PORT)元组，连接失败会报错（如服务器未启动、地址错误）
client_socket.connect((SERVER_HOST, SERVER_PORT))
print(f"已成功连接到服务器 {SERVER_HOST}:{SERVER_PORT}")
# 5. 定义要发送的消息，并编码为字节流（TCP传输需字节流，不能直接传字符串）
send_msg = "Hello, Server! This is Client."
client_socket.send(send_msg.encode('utf-8')) # encode('utf-8')：字符串转字节流
print(f"已向服务器发送消息：{send_msg}")
# 6. 关闭客户端Socket
client_socket.close()
print("客户端已关闭连接")
3. 运行演示（Windows/macOS/Linux通用）
需打开两个终端窗口，分别运行服务器端和客户端，步骤如下：
步骤1：运行服务器端
1. 打开第一个终端，进入代码所在的文件夹（如用 cd 文件夹路径 命令切换目录）；
2. 执行命令： python server.py （若系统默认Python3，需用 python3 server.py ）；
3. 终端显示：
服务器已启动，正在 127.0.0.1:8080 等待客户端连接... ，此时服务器进入“阻塞等待”状态。
步骤2：运行客户端
1. 打开第二个终端，同样进入代码所在文件夹；
2. 执行命令： python client.py （或 python3 client.py ）；
3. 客户端终端显示：
已成功连接到服务器 127.0.0.1:8080
已向服务器发送消息：Hello, Server! This is Client.
客户端已关闭连接
步骤3：查看服务器端结果
此时第一个终端（服务器端）会自动刷新，显示：
成功连接客户端：('127.0.0.1', 54321) # 54321是客户端随机端口，每次可能不同
收到客户端消息：Hello, Server! This is Client.
服务器已关闭连接
五、实战二：实现双向持续通信 (Practice 2: Bidirectional & Persistent Communication)
本实战在单向通信基础上升级，实现服务器与客户端的“聊天式”交互——双方可交替发送消息，直到某一方触发退出指令（如发送“exit”），核心是通过 while 循环实现持续数据处理，并定义简单的“通信协议”（退出指令）避免程序无限运行。
1. 核心设计思路
- 持续通信：用 while True 循环让服务器和客户端持续执行“接收→发送”逻辑，替代单次数据交互。
- 双向交互：双方均需包含 recv() （接收对方消息）和 send() （发送己方消息）代码，而非仅一方发送、一方接收。
- 退出机制：定义“通信协议”——当任意一方发送“exit”时，另一方识别该指令，关闭连接并退出循环，避免程序卡死。
2. 服务器端代码（ server_bidirectional.py ）
服务器在接受连接后，通过循环持续与客户端交互，代码及关键说明如下：
import socket
# 服务器配置（与客户端保持一致）
HOST = '127.0.0.1'
PORT = 8080
# 1. 创建并初始化Socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen(5)
print(f"服务器启动，等待连接（{HOST}:{PORT}）...")
# 2. 接受客户端连接（仅处理单个客户端，简化演示）
conn, client_addr = server_socket.accept()
print(f"客户端 {client_addr} 已连接，可开始聊天（发送'exit'退出）
")
# 3. 循环实现双向持续通信
while True:
# 3.1 接收客户端消息
# recv(1024)：每次最多接收1024字节，解码为字符串
client_msg = conn.recv(1024).decode('utf-8')
# 3.2 处理退出指令：若客户端发"exit"，关闭连接并退出循环
if client_msg.lower() == 'exit':
print(f"客户端 {client_addr} 发起退出，通信结束")
break # 跳出循环，结束通信
# 3.3 打印客户端消息，并获取服务器输入
print(f"客户端：{client_msg}")
server_msg = input("服务器回复：") # 服务器手动输入消息
# 3.4 处理服务器退出：若服务器输入"exit"，发送指令后退出
if server_msg.lower() == 'exit':
conn.send(server_msg.encode('utf-8')) # 先发送退出指令给客户端
print("服务器主动退出，通信结束")
break
# 3.5 发送服务器消息给客户端
conn.send(server_msg.encode('utf-8'))
# 4. 关闭连接，释放资源
conn.close() # 关闭与客户端的通信连接
server_socket.close() # 关闭服务器监听Socket
print("所有连接已关闭")
3. 客户端代码（ client_bidirectional.py ）
客户端逻辑与服务器对称，通过循环实现“输入消息→发送→接收回复”的持续流程：
import socket
# 服务器配置（必须与服务器端完全一致）
SERVER_HOST = '127.0.0.1'
SERVER_PORT = 8080
# 1. 创建并连接服务器
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((SERVER_HOST, SERVER_PORT))
print(f"已连接服务器（{SERVER_HOST}:{SERVER_PORT}），可开始聊天（发送'exit'退出）
")
# 2. 循环实现双向持续通信
while True:
# 2.1 客户端输入消息
client_msg = input("客户端发送：")
# 2.2 处理客户端退出：若输入"exit"，发送指令后退出
if client_msg.lower() == 'exit':
client_socket.send(client_msg.encode('utf-8'))
print("客户端主动退出，通信结束")
break
# 2.3 发送消息给服务器
client_socket.send(client_msg.encode('utf-8'))
# 2.4 接收服务器回复
server_msg = client_socket.recv(1024).decode('utf-8')
# 2.5 处理服务器退出：若服务器发"exit"，关闭连接并退出
if server_msg.lower() == 'exit':
print(f"服务器：{server_msg}（通信结束）")
break
# 2.6 打印服务器回复
print(f"服务器：{server_msg}")
# 3. 关闭客户端Socket
client_socket.close()
print("客户端连接已关闭")
这里我就不过多演示，大家自己去试试。
六、常见问题与难点解析 (Common Issues & Solutions)
在Socket编程实战中，常会遇到端口占用、数据粘包、程序阻塞等问题，以下针对核心问题拆解原因并提供可落地的解决方案。
1. Address already in use 错误（地址已被占用）
问题原因
最常见的场景是：服务器程序异常退出（如强制关闭终端）后，端口并未立即释放，处于TIME_WAIT状态（TCP协议规定，连接关闭后需保留端口一段时间，确保残留数据传输完成，默认约1-4分钟）。此时重新运行服务器，会因端口被占用报错。
解决方案
在创建Socket后、调用 bind() 前，设置 SO_REUSEADDR 选项，允许端口被重复使用，代码示例如下：
import socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 关键：开启端口复用，解决TIME_WAIT导致的端口占用问题
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 之后再执行绑定操作
server_socket.bind(('127.0.0.1', 8080)) # 此时不会因TIME_WAIT报错
2. 粘包问题 (TCP Stickiness)
问题原因
TCP是字节流协议，仅传输连续的字节数据，不维护“消息边界”。例如：
- 客户端分两次发送： "Hello" 和 "World" ；
- 服务器可能一次接收 b"HelloWorld" （两次数据被合并），或先接收 b"Hel" 、再接收 b"loWorld" （一次数据被拆分），导致无法正确识别单条消息，即“粘包”。
解决方案
需在应用层定义通信协议，明确消息的“开始”和“结束”，常用两种方案：
方案1：固定分隔符（简单易用）
为每条消息末尾添加特殊分隔符（如
、 ### ），服务器接收数据时，按分隔符拆分消息。
示例（客户端发送）：
# 每条消息末尾加"
"作为分隔符
client_socket.send("Hello
".encode('utf-8'))
client_socket.send("World
".encode('utf-8'))
示例（服务器接收）：
buffer = b"" # 用缓冲区暂存未拆分的字节流
while True:
data = conn.recv(1024)
if not data:
break
buffer += data
# 按"
"拆分缓冲区，获取完整消息
while b"
" in buffer:
msg, buffer = buffer.split(b"
", 1) # 拆分出一条完整消息
print("收到消息：", msg.decode('utf-8')) # 依次打印"Hello"、"World"
方案2：消息长度前缀（可靠稳定）
每条消息分为两部分：4字节长度前缀（表示后续消息的字节数）+ 消息内容。服务器先接收4字节获取长度，再按长度接收完整消息，适用于消息含分隔符的场景。
示例（客户端发送）：
import struct # 用于将长度转为4字节二进制
def send_msg(sock, msg):
msg_bytes = msg.encode('utf-8')
# 1. 计算消息长度（字节数），转为4字节二进制（大端序）
msg_len = struct.pack('>I', len(msg_bytes)) # '>I'表示大端序无符号int（4字节）
# 2. 发送“长度前缀+消息内容”
sock.send(msg_len + msg_bytes)
# 调用函数发送消息
send_msg(client_socket, "Hello")
send_msg(client_socket, "World")
示例（服务器接收）：
import struct
def recv_msg(sock):
# 1. 先接收4字节长度前缀
len_bytes = sock.recv(4)
if not len_bytes:
return None
# 2. 解析长度（将4字节二进制转为int）
msg_len = struct.unpack('>I', len_bytes)[0]
# 3. 按长度接收完整消息
msg_bytes = b""
while len(msg_bytes) < msg_len:
chunk = sock.recv(min(msg_len - len(msg_bytes), 1024)) # 每次最多收1024字节
if not chunk:
return None
msg_bytes += chunk
return msg_bytes.decode('utf-8')
# 调用函数接收消息
while True:
msg = recv_msg(conn)
if not msg:
break
print("收到消息：", msg) # 依次打印"Hello"、"World"
3. 阻塞（Blocking）与超时问题
问题原因
Socket默认是阻塞模式：调用 recv() 时，若没有数据到达，程序会一直“卡住”等待（阻塞）；调用 accept() 时，若没有客户端连接，程序也会阻塞。极端情况下（如客户端断开但未发通知），服务器会永久阻塞，导致程序卡死。
解决方案
通过 settimeout(seconds) 为Socket设置超时时间，超时后会抛出 socket.timeout 异常，避免程序永久阻塞，代码示例如下：
示例1：服务器 recv() 超时设置
conn, client_addr = server_socket.accept()
# 设置超时：若30秒内未收到客户端数据，触发超时异常
conn.settimeout(30)
try:
while True:
data = conn.recv(1024) # 若30秒无数据，抛出socket.timeout
if not data:
break
print("收到：", data.decode('utf-8'))
except socket.timeout:
print("超时警告：30秒内未收到客户端数据，关闭连接")
finally:
conn.close()
示例2：客户端 connect() 超时设置
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置超时：若5秒内未连接到服务器，触发超时异常
client_socket.settimeout(5)
try:
client_socket.connect(('127.0.0.1', 8080)) # 超时则抛出socket.timeout
except socket.timeout:
print("连接超时：5秒内未找到服务器，请检查地址或服务器状态")
4. 大数据传输问题
问题原因
recv(size) 每次最多接收 size 字节数据（如 recv(1024) 每次最多收1KB）。若传输大文件（如10MB），单次 recv() 无法接收完整数据，仅能获取部分字节流，导致数据不完整。
解决方案
需在循环中重复调用 recv() ，将每次接收的“数据块”拼接成完整数据，直到接收的总字节数达到预期（如文件大小），代码示例（以接收10MB文件为例）：
# 服务器端：接收10MB大数据（假设已知文件大小为10*1024*1024字节）
TARGET_SIZE = 10 * 1024 * 1024 # 10MB
received_data = b"" # 存储完整数据
while len(received_data) < TARGET_SIZE:
# 每次接收“剩余所需字节数”和“1024字节”中的较小值，避免浪费内存
chunk_size = min(TARGET_SIZE - len(received_data), 1024)
chunk = conn.recv(chunk_size)
if not chunk:
print("客户端断开连接，数据接收不完整")
break
received_data += chunk
if len(received_data) == TARGET_SIZE:
print(f"成功接收10MB数据，总字节数：{len(received_data)}")
# 后续可将received_data写入文件（如with open("big_file.dat", "wb") as f: f.write(received_data)）
七、进阶：使用多线程处理多客户端 (Advanced: Multi-Threading for Multiple Clients)
基础版服务器存在“单客户端瓶颈”——一次只能与一个客户端通信，其他客户端需排队等待。通过多线程可解决该问题：主线程负责监听新连接，每接收一个客户端就创建一个独立子线程处理通信，实现“同时服务多个客户端”。
1. 核心原理
- 主线程：仅执行 socket() → bind() → listen() → accept() 循环，专注于“接收新客户端连接”，不参与具体通信。
- 子线程：每当 accept() 成功获取一个客户端连接（ conn ），就创建一个子线程，将 conn 传入子线程，由子线程单独处理该客户端的“接收→发送”逻辑。
- 优势：子线程与主线程并行执行，一个客户端的通信不会阻塞其他客户端的连接请求。
2. 多线程服务器代码实现（ server_multi_thread.py ）
使用Python内置 threading 模块创建子线程，代码包含“主线程监听”“子线程通信”“退出处理”，标注清晰：
import socket
import threading
# 服务器配置
HOST = '127.0.0.1'
PORT = 8080
MAX_CLIENTS = 5 # 最多同时服务5个客户端（子线程数量上限）
# --------------------------
# 子线程函数：处理单个客户端的双向通信
# --------------------------
def handle_client(conn, client_addr):
"""
conn: 与该客户端通信的Socket对象
client_addr: 客户端地址（IP+端口）
"""
print(f"
新客户端连接：{client_addr}，当前活跃线程数：{threading.active_count()-1}")
conn.settimeout(60) # 设置60秒超时，避免线程永久阻塞
try:
# 子线程的通信循环（与单个客户端交互）
while True:
# 1. 接收客户端消息
client_msg = conn.recv(1024).decode('utf-8')
if not client_msg: # 客户端断开连接（recv返回空字节）
print(f"客户端 {client_addr} 主动断开连接")
break
# 2. 处理退出指令
if client_msg.lower() == 'exit':
print(f"客户端 {client_addr} 发送退出指令")
conn.send("exit".encode('utf-8')) # 回复退出指令
break
# 3. 打印并回复客户端消息
print(f"[{client_addr}] 客户端：{client_msg}")
server_msg = input(f"回复 [{client_addr}]：")
if server_msg.lower() == 'exit':
conn.send("exit".encode('utf-8'))
print(f"服务器主动断开与 {client_addr} 的连接")
break
conn.send(server_msg.encode('utf-8'))
except socket.timeout:
print(f"客户端 {client_addr} 超时（60秒无数据），断开连接")
except Exception as e:
print(f"与 {client_addr} 通信出错：{str(e)}")
finally:
# 关闭当前客户端的连接，释放资源
conn.close()
print(f"客户端 {client_addr} 连接已关闭，当前活跃线程数：{threading.active_count()-1}")
# --------------------------
# 主线程：监听客户端连接，创建子线程
# --------------------------
def main():
# 1. 初始化服务器Socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 解决端口占用
server_socket.bind((HOST, PORT))
server_socket.listen(MAX_CLIENTS) # 最大等待连接数=最大客户端数
print(f"多线程服务器启动，监听 {HOST}:{PORT}，最多支持 {MAX_CLIENTS} 个客户端同时连接")
print("主线程：等待客户端连接...（按Ctrl+C退出）")
try:
# 2. 循环接收新客户端（主线程核心逻辑）
while True:
conn, client_addr = server_socket.accept() # 阻塞等待新连接
# 3. 检查当前活跃线程数（避免线程过多导致资源耗尽）
if threading.active_count() - 1 >= MAX_CLIENTS:
conn.send("服务器当前繁忙，请稍后再试！".encode('utf-8'))
conn.close()
print(f"拒绝客户端 {client_addr} 连接：已达最大客户端数 {MAX_CLIENTS}")
continue
# 4. 创建子线程，传入“客户端连接”和“处理函数”
# daemon=True：设置为守护线程，主线程退出时子线程自动退出
client_thread = threading.Thread(
target=handle_client, # 子线程要执行的函数
args=(conn, client_addr), # 传给函数的参数
daemon=True
)
client_thread.start() # 启动子线程
except KeyboardInterrupt:
print("
主线程：收到退出指令（Ctrl+C）")
finally:
# 5. 关闭服务器Socket
server_socket.close()
print("多线程服务器已关闭")
# 启动服务器
if __name__ == "__main__":
main()
3. 运行演示：多客户端同时连接
需打开1个服务器终端 + 多个客户端终端，步骤如下：
步骤1：启动多线程服务器
终端1执行： python server_multi_thread.py ，显示：
多线程服务器启动，监听 127.0.0.1:8080，最多支持 5 个客户端同时连接
主线程：等待客户端连接...（按Ctrl+C退出）
步骤2：启动多个客户端
- 终端2执行： python client_bidirectional.py （客户端1），连接成功后可发送消息；
- 终端3执行： python client_bidirectional.py （客户端2），服务器终端1显示：
新客户端连接：('127.0.0.1', 54321)，当前活跃线程数：1
新客户端连接：('127.0.0.1', 54322)，当前活跃线程数：2
- 客户端1和客户端2可分别发送消息，服务器会通过不同子线程处理，例如：
- 客户端1发送： 我是客户端1 ，服务器终端1显示： [(127.0.0.1, 54321)] 客户端：我是客户端1 ，输入回复后客户端1可接收；
- 客户端2发送： 我是客户端2 ，服务器终端1显示： [(127.0.0.1, 54322)] 客户端：我是客户端2 ，输入回复后客户端2可接收。
步骤3：测试客户端退出
客户端1发送 exit ，服务器终端1显示：
客户端 ('127.0.0.1', 54321) 发送退出指令
客户端 ('127.0.0.1', 54321) 连接已关闭，当前活跃线程数：1
4. 注意事项与进阶方向
（1）多线程的局限性
- GIL锁影响：Python的全局解释器锁（GIL） 导致同一时间只有一个线程执行Python字节码，多线程在CPU密集型任务（如大量计算）中无法真正并行，仅适合IO密集型任务（如Socket通信，大部分时间在等待数据传输）。
- 资源消耗：每个线程占用独立的内存栈（默认约1MB），客户端数量过多（如上千个）时，线程数量激增会导致内存耗尽，且线程切换开销大。
（2）更高效的替代方案
- 多进程（ multiprocessing ）：每个进程有独立的GIL，可实现真正的CPU并行，适合CPU密集型+多客户端场景，但进程间通信（IPC）复杂度高于线程，内存占用也更大。
- 异步IO（ asyncio ）：基于“事件循环”模型，用单线程处理多个客户端的IO请求，避免线程切换开销，适合高并发（如上万客户端）的IO密集型场景，是当前高性能网络编程的主流方案（如Python的 aiohttp 库）。
（3）线程安全问题
若多个子线程需要操作共享资源（如全局变量、数据库连接），需通过 threading.Lock() 加锁，避免数据竞争（如两个线程同时修改同一变量导致数据错误）。例如：
# 定义共享资源和锁
shared_count = 0
lock = threading.Lock()
def update_count():
global shared_count
with lock: # 自动加锁和释放锁，确保同一时间只有一个线程执行内部代码
shared_count += 1
创作不易，点个赞再走吧！！！
