Python多线程编程全解析：基础到高级用法

 
Python中有多线程的支持。Python的threading模块提供了多线程编程的基本工具。在下面，我将列举一些基础的多线程用法和一些高级用法，并提供相应的源代码，其中包含中文注释。
基础用法：

创建和启动线程

1. import threading
2. import time
4. # 定义一个简单的线程类
5. class MyThread(threading.Thread):
6.     def run(self):
7.         for _ in range(5):
8.             print(threading.current_thread().name, "is running")
9.             time.sleep(1)
11. # 创建两个线程实例
12. thread1 = MyThread(name="Thread-1")
13. thread2 = MyThread(name="Thread-2")
15. # 启动线程
16. thread1.start()
17. thread2.start()
19. # 主线程等待所有子线程结束
20. thread1.join()
21. thread2.join()
23. print("Main thread exiting")

复制代码

线程同步 - 使用锁

1. import threading
3. # 共享资源
4. counter = 0
6. # 创建锁
7. counter_lock = threading.Lock()
9. # 定义一个简单的线程类
10. class MyThread(threading.Thread):
11.     def run(self):
12.         global counter
13.         for _ in range(5):
14.             with counter_lock:  # 使用锁保护临界区
15.                 counter += 1
16.                 print(threading.current_thread().name, "Counter:", counter)
18. # 创建两个线程实例
19. thread1 = MyThread(name="Thread-1")
20. thread2 = MyThread(name="Thread-2")
22. # 启动线程
23. thread1.start()
24. thread2.start()
26. # 主线程等待所有子线程结束
27. thread1.join()
28. thread2.join()
30. print("Main thread exiting")

复制代码

高级用法：

使用线程池

1. import concurrent.futures
2. import time
4. # 定义一个简单的任务函数
5. def task(name):
6.     print(f"{name} is running")
7.     time.sleep(2)
8.     return f"{name} is done"
10. # 使用线程池
11. with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
12.     # 提交任务给线程池
13.     future_to_name = {executor.submit(task, f"Thread-{i}"): f"Thread-{i}" for i in range(5)}
15.     # 获取任务结果
16.     for future in concurrent.futures.as_completed(future_to_name):
17.         name = future_to_name[future]
18.         try:
19.             result = future.result()
20.             print(f"{name}: {result}")
21.         except Exception as e:
22.             print(f"{name}: {e}")

复制代码

使用Condition进行线程间通信

1. import threading
2. import time
4. # 共享资源
5. shared_resource = None
7. # 创建条件变量
8. condition = threading.Condition()
10. # 定义一个写线程
11. class WriterThread(threading.Thread):
12.     def run(self):
13.         global shared_resource
14.         for _ in range(5):
15.             with condition:
16.                 shared_resource = "Write data"
17.                 print("Writer wrote:", shared_resource)
18.                 condition.notify()  # 通知等待的线程
19.                 condition.wait()  # 等待其他线程通知
21. # 定义一个读线程
22. class ReaderThread(threading.Thread):
23.     def run(self):
24.         global shared_resource
25.         for _ in range(5):
26.             with condition:
27.                 while shared_resource is None:
28.                     condition.wait()  # 等待写线程通知
29.                 print("Reader read:", shared_resource)
30.                 shared_resource = None
31.                 condition.notify()  # 通知写线程
33. # 创建写线程和读线程
34. writer_thread = WriterThread()
35. reader_thread = ReaderThread()
37. # 启动线程
38. writer_thread.start()
39. reader_thread.start()
41. # 主线程等待所有子线程结束
42. writer_thread.join()
43. reader_thread.join()
45. print("Main thread exiting")

复制代码

这些例子涵盖了一些基础和高级的多线程用法。请注意，在Python中由于全局解释器锁（GIL）的存在，多线程并不能充分利用多核处理器。如果需要充分利用多核处理器，可以考虑使用multiprocessing模块进行多进程编程。
 


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！