基本语法：

thread = Thread(target=task_function)
thread.start()
thread.join()  # 主线程在此等待直到thread线程完成

示例：并行下载多个文件

import threading
import time
import random

def download_file(url):
    print(f"开始下载: {url}")
    time.sleep(random.uniform(1, 3))  # 模拟下载时间
    print(f"完成下载: {url}")

# 创建多个下载线程
urls = ["https://example.com/file1.zip", 
        "https://example.com/file2.pdf",
        "https://example.com/file3.jpg"]

threads = []
for url in urls:
    t = threading.Thread(target=download_file, args=(url,))
    threads.append(t)
    t.start()

# 等待所有下载线程完成
print("主线程：等待所有下载完成...")
for t in threads:
    t.join()

print("主线程：所有文件下载完成！开始处理文件...")

执行结果分析：

如果不使用join()，主线程会在启动所有下载线程后立即打印"所有文件下载完成..."，但实际上下载仍在进行。使用join()确保主线程在所有下载完成后才继续执行。

示例：数据处理流水线

import threading

def data_collection():
    print("数据采集线程：开始收集数据...")
    # 模拟数据采集
    threading.Event().wait(2)  
    print("数据采集线程：数据收集完成！")
    return "采集的数据"

def data_processing(raw_data):
    print("数据处理线程：开始处理数据...")
    # 模拟数据处理
    threading.Event().wait(1.5)
    processed_data = raw_data + " -> 已处理"
    print("数据处理线程：数据处理完成！")
    return processed_data

def data_saving(processed_data):
    print("数据保存线程：开始保存数据...")
    # 模拟数据保存
    threading.Event().wait(1)
    print(f"数据保存线程：已保存数据: {processed_data}")

# 创建并启动数据采集线程
collect_thread = threading.Thread(target=data_collection)
collect_thread.start()

# 等待数据采集完成
collect_thread.join()

# 获取采集的数据
raw_data = data_collection()  # 实际中可能需要通过队列或共享变量传递

# 创建并启动数据处理线程
process_thread = threading.Thread(target=data_processing, args=(raw_data,))
process_thread.start()

# 等待数据处理完成
process_thread.join()
processed_data = data_processing(raw_data)  # 同样需要传递数据

# 创建并启动数据保存线程
save_thread = threading.Thread(target=data_saving, args=(processed_data,))
save_thread.start()
save_thread.join()

print("所有数据处理流程完成！")

示例：服务关闭时等待工作线程完成

import threading
import time

# 工作线程函数
def worker(stop_event):
    while not stop_event.is_set():
        print("工作线程：处理任务中...")
        time.sleep(1)
    print("工作线程：收到停止信号，正在完成最后任务...")
    time.sleep(0.5)  # 模拟清理操作
    print("工作线程：已安全退出")

# 创建停止事件
stop_event = threading.Event()

# 创建工作线程
worker_thread = threading.Thread(target=worker, args=(stop_event,))
worker_thread.start()

# 主线程运行一段时间
print("主线程：服务运行中...")
time.sleep(5)

# 发出停止信号
print("主线程：发送停止信号...")
stop_event.set()

# 等待工作线程完成
print("主线程：等待工作线程退出...")
worker_thread.join()

print("主线程：所有线程已安全退出，程序结束")

关键点：

此模式结合了事件(Event)和join()，实现优雅停止：

1. 通过事件对象通知线程停止
2. 线程收到信号后完成当前任务
3. 主线程使用join()等待线程完成清理
4. 确保所有资源正确释放

示例：控制最长等待时间

import threading
import time

def long_running_task():
    print("长时间任务：开始执行...")
    time.sleep(10)  # 模拟长时间任务
    print("长时间任务：完成！")

# 创建并启动线程
t = threading.Thread(target=long_running_task)
t.start()

# 最多等待5秒
print("主线程：等待任务完成，最多5秒...")
t.join(timeout=5)

if t.is_alive():
    print("主线程：任务仍在运行，中断等待继续执行主线程")
else:
    print("主线程：任务已完成")

print("主线程继续执行...")

使用场景：

• 避免因线程卡死导致主线程永久阻塞
• 需要设置任务执行超时时间
• 在有限时间内收集尽可能多的结果
• 响应式系统需要及时处理用户请求

最终建议：

join()是Python多线程编程中简单而强大的同步工具。在简单场景中，它是确保线程完成的首选方案。对于更复杂的并发需求，可考虑结合队列、事件、线程池等机制构建更健壮的解决方案。