ToB企服应用市场:ToB评测及商务社交产业平台

标题: Python并发编程(1)——Python并发编程的几种实现方式 [打印本页]
作者: 王國慶    时间: 2024-10-3 15:00
标题: Python并发编程(1)——Python并发编程的几种实现方式
左手编程，右手光阴。大家好，我是一点，关注我，带你走入编程的世界。
公众号：一点sir，关注领取python编程资料
Python 并发编程是指在 Python 中编写能够同时实行多个使命的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的题目，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。

多线程 (Threading)

多线程是通过使用 threading 模块来创建和管理线程。线程是轻量级的过程，可以与同一进程中的其他线程共享数据和资源。然而，由于 Python 的全局解释器锁（GIL）的存在，假如用的解释器是CPython的话，那么多线程在 CPU 密集型使命上不会有性能提升的，但是IO密集型的是会有的。
  1. import threading
  2. import time
  4. def worker(num):
  5.     print(f"Worker {num} starting")
  6.     time.sleep(2)
  7.     print(f"Worker {num} finished")
  9. threads = []
  10. for i in range(5):
  11.     t = threading.Thread(target=worker, args=(i,))
  12.     threads.append(t)
  13.     t.start()
  15. # Wait for all threads to complete
  16. for t in threads:
  17.     t.join()
  18. print("All workers finished.")
复制代码
上面的例子中，通过threading模块中的Thread启动了另一个线程，输出中首先出现的是每个线程的启动消息，如 "Worker 0 starting"，然后是 "Worker 1 starting" 等等。
接下来是每个线程的完成消息，如 "Worker 0 finished"。由于线程的实行顺序不是固定的，因此现实输出中的线程完成顺序可能会有所不同。
全局解释器锁（GIL）是历史历史遗留下来的题目，在Python3.13可能会得到解决。
多进程 (Multiprocessing)

多进程则可以通过使用 multiprocessing 模块来创建独立的进程。每个进程都有自己的内存空间，因此可以绕过 GIL，适用于 CPU 密集型使命。
  1. from multiprocessing import Process
  2. import time
  4. def worker(num):
  5.     print(f"Worker {num} starting")
  6.     time.sleep(2)
  7.     print(f"Worker {num} finished")
  9. processes = []
  10. for i in range(5):
  11.     p = Process(target=worker, args=(i,))
  12.     processes.append(p)
  13.     p.start()
  15. # Wait for all processes to complete
  16. for p in processes:
  17.     p.join()
  18. print("All workers finished.")
复制代码
多进程与多线程示例类似，但这里是在不同的进程中实行。通过multiprocessing模块中的Process启动了另一个进程，每个进程开始和完成的消息按顺序出现。由于进程之间没有共享内存，每个进程都在独立的环境中运行，因此输出中的完成顺序与启动顺序相同。
异步编程 (Asyncio)

Python 3.4 引入了 asyncio 模块，它是一个用于编写单线程并发代码的模块，使用 async 和 await 关键字。异步编程允许你编写并发代码，以非阻塞的方式运行。这非常适合 I/O 密集型使命，如网络请求、文件操作等。
  1. import asyncio
  3. async def worker(num):
  4.     print(f"Worker {num} starting")
  5.     await asyncio.sleep(2)
  6.     print(f"Worker {num} finished")
  8. async def main():
  9.     tasks = [worker(i) for i in range(5)]
  10.     await asyncio.gather(*tasks)
  12. asyncio.run(main())
  13. print("All workers finished.")
复制代码
由于协程是基于事件循环的，因此输出中的完成顺序可能与启动顺序不同。异步编程也是python并发编程中比较紧张的一个概念，后面很大篇幅都要围绕这个异步编程来展开的。
使用 concurrent.futures

concurrent.futures 提供了一个高层次的接口来处理并行实行的使命，现实上就是线程池或者进程池的玩意，这个池的概念就是线程或者进程用完不烧毁，重复利用，具体后面展开说说。
示例：
  1. from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
  2. import time
  4. def worker(num):
  5.     print(f"Worker {num} starting")
  6.     time.sleep(2)
  7.     return f"Worker {num} finished"
  9. with ThreadPoolExecutor(max_workers=5) as executor:
  10.     futures = [executor.submit(worker, i) for i in range(5)]
  12. for future in futures:
  13.     print(future.result())
  15. print("All workers finished.")
复制代码
首先，创建了一个最大容纳 5 个工作线程的线程池。然后，提交了 5 个 worker 使命到线程池中，并立刻返回了 5 个 Future 对象。接着，程序遍历这些 Future 对象，等待每个使命完成，并打印它们的返回值。末了，打印全部工作线程已经完成的消息。不外还是那个题目，由于 Python 的全局解释器锁（GIL），在 CPU 密集型使命中，线程池并不会带来性能上的提升。
以上这些方法都可以根据你的具体需求来选择使用。假如你必要举行更多的细节控制或者有特定的性能要求，你还可以考虑使用更底层的 API 或者第三方库。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4