#Python多线程编程指南

import threading
import time

def worker():
    """子线程要做的事：假装忙一会儿（sleep模拟真实I/O）"""
    print(f'✅ 子线程 {threading.current_thread().name} 启动...')
    time.sleep(1)
    print(f'❌ 子线程 {threading.current_thread().name} 结束')

# 创建线程对象：target是要执行的函数，name给线程起个便于调试的名字
t = threading.Thread(target=worker, name='TestWorker')
t.start()  # 启动线程（只是告诉操作系统准备好了，具体什么时候执行看调度器）
t.join()   # join() 会**阻塞主线程**，直到子线程执行完，避免主线程提前退出看不到结果
print(f'🏁 主线程 {threading.current_thread().name} 结束')

import threading
import time

class CustomWorker(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)  # 必须先调用父类的初始化方法

    # 重写run()方法，子线程启动后执行的就是这个方法
    def run(self):
        print(f'✅ 自定义子线程 {self.name} 启动...')
        time.sleep(1)
        print(f'❌ 自定义子线程 {self.name} 结束')

t = CustomWorker(name='CustomTest')
t.start()
t.join()
print(f'🏁 主线程结束')

import threading

counter = 0  # 全局共享变量

def unsafe_increment():
    global counter
    for _ in range(100000):
        # 这一行代码底层其实是3步：读取counter、加1、写回counter
        # 多线程切换可能发生在这3步之间！
        counter += 1

threads = []
for _ in range(10):
    t = threading.Thread(target=unsafe_increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"❌ 不安全累加器最终值: {counter}")  # 多次运行试试，几乎不会是1000000

import threading

counter = 0
lock = threading.Lock()  # 创建一个全局互斥锁

def safe_increment():
    global counter
    for _ in range(100000):
        # with lock会自动获取锁，代码块结束自动释放
        with lock:
            counter += 1

threads = []
for _ in range(10):
    t = threading.Thread(target=safe_increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"✅ 安全累加器最终值: {counter}")  # 无论运行多少次，都是1000000

from concurrent.futures import ThreadPoolExecutor
import time

def square_task(n):
    """模拟一个带I/O的计算任务"""
    print(f"处理任务 {n}...")
    time.sleep(1)  # 模拟I/O
    return n * n

# 使用上下文管理器with，自动关闭线程池
with ThreadPoolExecutor(max_workers=4) as executor:  # max_workers建议设为CPU核心数*2左右（I/O密集型）
    # 提交10个任务，返回Future对象列表
    futures = [executor.submit(square_task, i) for i in range(10)]
    # 获取所有任务的结果（按提交顺序）
    results = [f.result() for f in futures]

print(f"🏁 所有任务结果: {results}")

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def square_task(n):
    time.sleep(n % 3)  # 让任务执行时间不一样
    return n * n

with ThreadPoolExecutor(max_workers=4) as executor:
    futures = {executor.submit(square_task, i): i for i in range(10)}
    # as_completed()会在任意一个任务完成时立即返回它的Future
    for future in as_completed(futures):
        n = futures[future]
        try:
            result = future.result()
            print(f"任务 {n} 完成，结果: {result}")
        except Exception as e:
            print(f"任务 {n} 出错: {e}")

import threading

# 创建一个全局的线程局部存储对象
local_db = threading.local()

def init_db_connection():
    """为当前线程初始化一个独立的数据库连接（模拟）"""
    local_db.conn = f"DBConn-{threading.current_thread().name}"

def use_db():
    """使用当前线程的数据库连接"""
    print(f"{threading.current_thread().name} 使用连接: {local_db.conn}")

def worker():
    init_db_connection()
    use_db()

threads = [
    threading.Thread(target=worker, name=f"Worker-{i}")
    for i in range(3)
]

for t in threads:
    t.start()
for t in threads:
    t.join()