线程创建进阶实战:Python 与 Go 语言篇
继 Java 和 C/C++ 之后,Python 和 Go 是现代高并发场景中最主流的选择。两者在线程(或协程)的创建模型上有着本质的区别:Python 受限于 GIL(全局解释器锁),侧重 I/O 密集型任务的线程优化;而 Go 则通过 Goroutine实现了轻量级用户态线程,完美解决高并发问题。
一、核心模型对比
| 语言 | 核心单元 | 创建关键字/函数 | 调度机制 | 适用场景 |
|---|---|---|---|---|
| Python | Thread (操作系统线程) | threading.Thread |
内核级调度,受 GIL 限制 | I/O 密集型任务(网络请求、文件读写) |
| Python | Process (多进程) | multiprocessing.Process |
多核并行,绕过 GIL | CPU 密集型任务(复杂计算、图像处理) |
| Go | Goroutine (用户态协程) | go 关键字 |
用户态调度 (GMP 模型) | 超高并发、微服务、实时通信 |
| Go | Channel (通信机制) | chan |
基于 CSP 模型通信 | 线程间安全数据交换,替代锁机制 |
注:Python 中由于 GIL 的存在,同一时刻只有一个线程在 CPU 上执行字节码,因此多线程无法利用多核优势进行纯计算任务,此时需切换至多进程模式 。
二、Python 线程与进程实战
1. 线程创建(I/O 密集型推荐)
适用于爬虫、数据库查询等等待时间较长的场景。
python
import threading
import time
def io_task(task_id):
"""模拟 I/O 耗时操作"""
print(f"线程 {task_id} 开始执行 I/O...")
time.sleep(2) # 模拟网络延迟
print(f"线程 {task_id} 完成")
if __name__ == "__main__":
threads = []
# 创建 5 个线程
for i in range(5):
# target 指定函数,args 传递参数
t = threading.Thread(target=io_task, args=(i,))
threads.append(t)
t.start() # 启动线程
#等待所有线程结束
for t in threads:
t.join()
print("所有任务执行完毕")
2. 进程创建(CPU 密集型推荐)
当任务涉及大量数学运算时,必须使用 multiprocessing 绕过 GIL 限制。
python
from multiprocessing import Process
import os
def cpu_task(task_id):
"""模拟 CPU 密集计算"""
print(f"进程 {task_id} (PID: {os.getpid()}) 正在计算...")
sum_val = 0
for i in range(10000000):
sum_val += i
print(f"进程 {task_id} 计算完成")
if __name__ == "__main__":
processes = []
# 创建 4 个进程,利用多核 CPU
for i in range(4):
p = Process(target=cpu_task, args=(i,))
processes.append(p)
p.start()
for p in processes:
p.join()
三、Go 语言 Goroutine 实战
Go 语言的线程创建极其轻量,启动一个 Goroutine 仅需几 KB 内存,且由运行时自动调度。
1. 基础 Goroutine 创建
使用 go 关键字即可将函数放入后台执行。
go
package main
import (
"fmt"
"time"
)
// 定义任务函数
func worker(id int) {
fmt.Printf("Goroutine %d 开始工作
", id)
time.Sleep(time.Second) // 模拟耗时
fmt.Printf("Goroutine %d 工作结束
", id)
}
func main() {
// 启动 5 个 Goroutine
for i := 1; i <= 5; i++ {
// go 关键字立即返回,不阻塞主线程
go worker(i)
} // 主线程等待,防止程序提前退出 // 实际生产中通常使用 sync.WaitGroup 而非 sleep
time.Sleep(2 * time.Second)
fmt.Println("主程序退出")
}
2. 线程同步:WaitGroup 标准模式
在生产环境中,严禁使用 time.Sleep 来等待协程,应使用 sync.WaitGroup 进行精确同步。
go
package main
import (
"fmt"
"sync"
"time"
)
func safeWorker(id int, wg *sync.WaitGroup) {// 任务完成后计数减 1
defer wg.Done()
fmt.Printf("安全协程 %d 运行中...
", id)
time.Sleep(500 * time.Millisecond)
fmt.Printf("安全协程 %d 已完成
", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 3; i++ {
// 计数加 1
wg.Add(1)
go safeWorker(i, &wg)}
// 阻塞直到计数归零
wg.Wait()
fmt.Println("所有协程同步完成")
}
四、关键选型建议
-
Python 选型法则:
- 若任务是等待型 (如请求 API、读写磁盘),直接使用
threading。 - 若任务是计算型 (如加密解密、矩阵运算),必须使用
multiprocessing,否则多线程效率甚至低于单线程 。 - 若追求极致 I/O 性能,可考虑
asyncio异步框架,而非传统线程。
- 若任务是等待型 (如请求 API、读写磁盘),直接使用
-
Go 选型法则:
- 默认使用 Goroutine:无需像 Java 那样配置线程池,Go 运行时会自动管理数千个协程。
- 通信优于共享 :尽量通过
Channel传递数据,避免多个 Goroutine 直接修改同一块内存,遵循 "Don't communicate by sharing memory; share memory by communicating" 原则。 - 异常捕获 :Goroutine 中发生的 panic 若未 recover,会导致整个程序崩溃,务必在入口函数处添加
defer recover()保护。