📚 Python 进阶系列 | 第三篇
上一篇学了多进程和多线程，但多线程有个"坑"——线程安全。多个线程同时修改共享数据，结果可能和你预期的不一样！
这篇用多线程买票系统实战讲解互斥锁，最后教你用 Python 写一个 UDP 聊天室，让程序能"联网"！
一、线程安全：一个"隐形"的坑
先看一个"翻车"的例子
假设我们有一个全局变量 g_num = 0，两个线程各自给它加 10 次 1，你猜最终结果是多少？
直觉告诉我们：应该是 20，对吧？
import threadingimport timeg_num = 0def func(): global g_num for _ in range(10): tmp = g_num + 1 # ① 读取 g_num time.sleep(0.3) # ② 模拟耗时操作（让问题更容易暴露） g_num = tmp # ③ 写回 g_num print(f”{threading.current_thread().name}: {g_num}”)if __name__ == ”__main__”: t1 = threading.Thread(target=func, name=”线程1”) t2 = threading.Thread(target=func, name=”线程2”) t1.start() t2.start() t1.join() t2.join() print(f”最终结果: {g_num}”)# 期望 20，但实际可能只有 10 出头！
为什么会"翻车"？
问题出在这三步操作不是原子操作：
① 读取 g_num 的值② 计算 g_num + 1③ 写回 g_num
线程切换的灾难现场：
时间线 线程1 线程2────────────────────────────────────────────────────T1 读取 g_num = 0T2 计算 0 + 1 = 1T3 读取 g_num = 0 ← 还是 0！T4 计算 0 + 1 = 1T5 写回 g_num = 1T6 写回 g_num = 1 ← 又写回 1！
💡 两个线程都读到了 g_num = 0，各自加 1 后都写回 1，第二次加 1 被覆盖了。
这就是线程不安全：多个线程同时修改共享变量，结果不可预期。
二、互斥锁：给共享资源"上锁"
什么是互斥锁？
互斥锁（Mutex Lock）就像公厕的门锁：
import threadinglock = threading.Lock()lock.acquire()# 获取锁（锁门）# ... 操作共享资源（上厕所）...lock.release()# 释放锁（开门）
用锁保护共享变量
import threadingimport timeg_num = 0lock = threading.Lock() # 创建一把锁def func(): global g_num for _ in range(10): lock.acquire() # 🔒 获取锁 tmp = g_num + 1 time.sleep(0.3) g_num = tmp print(f”{threading.current_thread().name}: {g_num}”) lock.release() # 🔓 释放锁if __name__ == ”__main__”: threads = [threading.Thread(target=func, name=f”线程{i}”) for i inrange(1, 4)] [t.start() for t in threads] [t.join() for t in threads] print(f”最终结果: {g_num}”)# 30 ✅ 每次都正确！
💡 加了锁之后，三个线程排队执行，g_num 从 0 加到 30，结果完全正确。
更优雅的写法：with 语句
手动 acquire/release 容易忘，推荐用 with 语句，自动释放锁：
lock = threading.Lock()with lock: # 自动 acquire，离开 with 块自动 release g_num += 1
💡 即使 with 块中发生异常，锁也会被正确释放，避免死锁。
三、实战：多线程买票系统 🎫
12306 抢票大家都经历过。如果多个窗口同时卖票，怎么保证不"超卖"？
import threadingimport timeticket_num = 100 # 总票数lock = threading.Lock()def buy_ticket(): global ticket_num while True: lock.acquire() # 🔒 获取锁 if ticket_num <= 0: # 检查是否还有票 lock.release() # ⚠️ 没票了，先释放锁！ break # 然后退出 time.sleep(0.1) # 模拟出票时间 ticket_num -= 1 # 卖一张票 print(f”{threading.current_thread().name}卖了1张票, 还剩{ticket_num}张”) lock.release() # 🔓 释放锁if __name__ == ”__main__”: threads = [ threading.Thread(target=buy_ticket, name=f”窗口{i}”) for i inrange(1, 4) ] [t.start() for t in threads] [t.join() for t in threads] print(f”售票结束，剩余票数: {ticket_num}”)
⚠️ 最容易犯的错误
# ❌ 错误写法：忘记释放锁if ticket_num <= 0: break# 直接退出，锁没释放 → 死锁！# ✅ 正确写法：先释放锁，再退出if ticket_num <= 0: lock.release() # 先释放锁 break # 再退出
💡死锁：锁被占用但永远不释放，其他线程全部卡住，程序"冻住"了。
四、GIL：Python 多线程的"天花板"
什么是 GIL？
CPython 解释器中有一个全局解释器锁（GIL，Global Interpreter Lock），它保证了同一时刻只有一个线程在执行 Python 字节码。
GIL 的影响
你以为的多线程：CPU 核心1: 线程1 →→→→→→→→CPU 核心2: 线程2 →→→→→→→→CPU 核心3: 线程3 →→→→→→→→实际上的多线程（CPython）：CPU 核心1: 线程1 → 线程2 → 线程3 → 线程1 → ...CPU 核心2: 空闲CPU 核心3: 空闲
💡 即使有多个 CPU 核心，Python 多线程也只能在一个核心上交替执行。
那多线程还有用吗？
当然有！看任务类型：
💡I/O 密集型任务在等待 I/O 时会释放 GIL，其他线程可以继续执行，所以多线程效果很好。
五、UDP 网络编程：让你的程序"联网"
什么是 UDP？
UDP（User Datagram Protocol）是一种无连接的传输协议。打个比方：
- UDP 像寄明信片：写好地址直接寄，不确认对方是否收到
- TCP 像打电话：先拨号、等接通、再通话、最后挂断
Socket 是什么？
Socket（套接字）是网络通信的端点，就像电话的"听筒"：
创建 Socket → 拿起电话听筒绑定 IP 和端口 → 分配一个电话号码发送/接收数据 → 开始通话
UDP 服务端（接收方）
import socket# ① 创建 socket 对象# AF_INET: IPv4 SOCK_DGRAM: UDP 协议sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)# ② 绑定 IP 和端口（相当于”分配电话号码”）sock.bind(('127.0.0.1', 8888))print(”服务端启动，等待客户端消息...”)# ③ 循环接收消息while True: # 接收数据（阻塞等待） recv_data, client_info = sock.recvfrom(1024) # recv_data: 字节数据 client_info: (IP, 端口) msg = recv_data.decode('utf-8') print(f”客户端 {client_info[0]}:{client_info[1]} 说: {msg}”) # ④ 回复消息 reply = f”服务器收到: {msg}” sock.sendto(reply.encode('utf-8'), client_info)sock.close()
💡 recvfrom() 返回一个元组：(字节数据, (客户端IP, 端口))。
UDP 客户端（发送方）
import socket# ① 创建 socket 对象sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)server_addr = (”127.0.0.1”, 8888)print(”客户端启动，输入消息发送给服务器...”)# ② 循环发送消息while True: msg = input(”你说: ”) # 发送数据（需要指定服务器地址） sock.sendto(msg.encode('utf-8'), server_addr) # 接收服务器回复 recv_data, server_info = sock.recvfrom(1024) print(f”服务器说: {recv_data.decode('utf-8')}”)sock.close()
💡 客户端不需要bind()，系统会自动分配一个随机端口。
运行效果
终端 1 —— 启动服务端：
$ python server.py服务端启动，等待客户端消息...客户端 127.0.0.1:54321 说: 你好客户端 127.0.0.1:54321 说: Python 真好玩
终端 2 —— 启动客户端：
$ python client.py客户端启动，输入消息发送给服务器...你说: 你好服务器说: 服务器收到: 你好你说: Python 真好玩服务器说: 服务器收到: Python 真好玩
六、编解码：别忘了这一步
网络传输的是字节（bytes），不是字符串。发送和接收时要做编解码：
# 发送时：字符串 → 字节（编码）msg = ”你好”data = msg.encode('utf-8')# b'\xe4\xbd\xa0\xe5\xa5\xbd'# 接收时：字节 → 字符串（解码）recv_data = b'\xe4\xbd\xa0\xe5\xa5\xbd'msg = recv_data.decode('utf-8') # ”你好”
⚠️ 编码和解码必须用相同的字符集（通常是 utf-8），否则乱码。
七、编码过程中的特殊字符处理
在网络传输中，如果数据包含特殊字符或中文，编码格式不一致会导致乱码。建议统一使用 utf-8：
# ✅ 推荐sock.sendto(”你好”.encode('utf-8'), addr)msg = recv_data.decode('utf-8')# ❌ 不推荐：不同系统默认编码可能不同sock.sendto(”你好”.encode(), addr) # 默认编码，不可控
本篇小结
| |
|---|
| |
| threading.Lock() |
| |
| |
| 全局解释器锁，限制了 Python 多线程的多核能力 |
| |
| 网络通信端点，AF_INET + SOCK_DGRAM 创建 UDP 套接字 |
| bind() 绑定端口，recvfrom() 接收，sendto() 发送 |
| 不需要 bind()，直接 sendto() 发送 |
| encode('utf-8') |
下篇预告
网络编程学会了，但每次都要手写正则来校验手机号、邮箱太麻烦。下一篇我们学习 Python 的正则表达式，并用它做一个完整的客户管理系统！
📝 学习建议：并发编程和网络编程是 Python 实战开发的核心技能。建议动手实现一个简单的聊天室，把多线程、锁、Socket 都用上。
觉得有用？点个「在看」让更多人看到 👇
有问题欢迎留言，我会一一回复！
