Python -- 多进程

  • 由于Python的GIL全局解释器锁存在,多线程未必是CPU密集型程序的好的选择
  • 多进程可以完全独立的进程环境中运行程序,可以较充分地利用多处理器
  • 但是进程本身的隔离带来的数据不共享也是一个问题。而且线程比进程轻量级

multiprocessing

Process类

  • Process类遵循了Thread类的API
import multiprocessing
import datetime

def calc(i):
    sum = 0
    for _ in range(1000000000): # 10亿
        sum += 1
    return i, sum

if __name__ == '__main__':
    start = datetime.datetime.now()

    ps = []
    for i in range(4):
        p = multiprocessing.Process(target=calc, args=(i,), name='calc-{}'.format())
        ps.append(p)
        p.start()

    for p in ps:
        p.join()
        print(p.name, p.exitcode)

    delta = (datetime.datetime.now() - start).total_seconds()
    print(delta)
    print('===end===')

对于上面这个程序,在同一主机上运行时长的对比

  • 使用单线程、多线程跑了4分钟多
  • 多进程用了1分半
    看到了多个进程都在使用CPU,这是真并行

注意

多进程代码一定要放在__name__ == "__main__"下面执行

名称说明
pid进程id
exitcode进程的退出状态码
terminate()终止指定的进程

进程间同步

  • Python在进程间同步提供了和线程同步一样的类,使用的方法一样,使用的效果也类似
  • 不过,进程间代价要高于线程间,而且系统底层实现是不同的,只不过Python屏蔽了这些不同之处,让用户简单使用多进程
  • multiprocessing还提供共享内存、服务器进程来共享数据,还提供了用于进程间通讯的Queue队列、Pipe管道
  • 通信方式不同
    1. 多进程就是启动多个解释器进程,进程间通信必须序列化、反序列化
    2. 数据的线程安全性问题
      如果每个进程中没有实现多线程,GIL可以说没什么用了

进程池举例

  • multiprocessing.Pool 是进程池类
名称说明
apply(self, func, args=(), kwds={})阻塞执行,导致主进程执行其他子进程就像一个个执行
apply_async(self, func, args=(), kwds={}, callback=None, error_callback=None)与apply方法用法一致,非阻塞异步执行,得到结果后会执行回调
close()关闭池,池不能再接受新的任务,所有任务完成后退出进程
terminate()立即结束工作进程,不再处理未处理的任务
join()主进程阻塞等待子进程的退出, join方法要在close或terminate之后使用

同步调用

  • pool.apply 同步阻塞的方法,多进程串行
import logging
import datetime
import multiprocessing

# 日志打印进行id、进程名、线程id、线程名
logging.basicConfig(level=logging.INFO,
                    format="%(process)d %(processName)s %(thread)d %(message)s")

def calc(i):
    sum = 0
    for _ in range(1000000000): # 10亿
        sum += 1
    logging.info(sum)
    return i, sum # 进程要return,才可以拿到这个结果

if __name__ == '__main__':
    start = datetime.datetime.now()

    pool = multiprocessing.Pool(4)
    for i in range(4):
        # 返回值,同步调用,注意观察CPU使用
        ret = pool.apply(calc, args=(i,))
        print(ret)
    pool.close()
    pool.join()

    delta = (datetime.datetime.now() - start).total_seconds()
    print(delta)
    print('===end===')
  • 执行结果
333980 SpawnPoolWorker-1 332164 1000000000
(0, 1000000000)
(1, 1000000000)
332272 SpawnPoolWorker-3 332200 1000000000
(2, 1000000000)
334224 SpawnPoolWorker-4 324984 1000000000
332264 SpawnPoolWorker-2 332232 1000000000
(3, 1000000000)
483.274714
===end===
  • cup使用情况,4个进程串行处理
    在这里插入图片描述

异步调用

  • pool.aaply_async 异步非阻塞,真并行
import logging
import datetime
import multiprocessing

# 日志打印进行id、进程名、线程id、线程名
logging.basicConfig(level=logging.INFO,
                    format="%(process)d %(processName)s %(thread)d %(message)s")

def calc(i):
    sum = 0
    for _ in range(1000000000): # 10亿
        sum += 1
    logging.info(sum)
    return i, sum # 进程要return,callback才可以拿到这个结果

if __name__ == '__main__':
    start = datetime.datetime.now()

    pool = multiprocessing.Pool(4)
    for i in range(4):
        # 异步拿到的返回值是什么,回调起了什么作用
        ret = pool.apply_async(
            calc, args=(i,),callback=lambda ret: logging.info('{} in callback'.format(ret)))

        print(ret, '~~~~~~~')
    pool.close()
    pool.join()

    delta = (datetime.datetime.now() - start).total_seconds()
    print(delta)
    print('===end===')
  • 执行结果
<multiprocessing.pool.ApplyResult object at 0x0000015814F616D8> ~~~~~~~
<multiprocessing.pool.ApplyResult object at 0x0000015814F61780> ~~~~~~~
<multiprocessing.pool.ApplyResult object at 0x0000015814F618D0> ~~~~~~~
<multiprocessing.pool.ApplyResult object at 0x0000015814F61978> ~~~~~~~
335068 SpawnPoolWorker-4 208444 1000000000
334080 MainProcess 335552 (2, 1000000000) in callback
332176 SpawnPoolWorker-2 334620 1000000000
334080 MainProcess 335552 (1, 1000000000) in callback
328432 SpawnPoolWorker-1 335124 1000000000
334080 MainProcess 335552 (0, 1000000000) in callback
334840 SpawnPoolWorker-3 335532 1000000000
334080 MainProcess 335552 (3, 1000000000) in callback
204.866947
===end===
  • cpu运行情况,4个进程并行处理
    在这里插入图片描述

多进程、多线程的选择

  1. CPU密集型
    CPython中使用到了GIL,多线程的时候锁相互竞争,且多核优势不能发挥,选用Python多进程效率更高
  2. IP密集型
    在Python中适合是用多线程,可以减少多进程间IO的序列化开销。且在IO等待的时候,切换到其他线程继续执行,效率不错

应用

请求/应答模型:WEB应用中常见的处理模型

  • master启动多个worker工作进程,一般和CPU数目相同。发挥多核优势
  • worker工作进程中,往往需要操作网络IO和磁盘IO,启动多线程,提高并发处理能力。worker处理用户的请求,往往需要等待数据,处理完请求还要通过网络IO返回响应
  • 这就是nginx工作模式
### Python 中进程与线程的概念 #### 进程 (Process) 进程是指操作系统结构中的基本单元,拥有独立的地址空间。每个进程都有自己私有的数据段、堆栈区和全局变量等资源,在创建子进程时会复制父进程的数据副本[^3]。 - **优点** - 更高的稳定性:由于各进程间相互隔离,一个进程崩溃不会影响其他进程。 - **缺点** - 创建销毁成本高:因为涉及内存分配等问题,所以开销较大。 - 数据共享困难:不同进程之间传递消息较为复杂。 ```python from multiprocessing import Process, Queue def f(q): q.put([42, None, 'hello']) if __name__ == '__main__': queue = Queue() p = Process(target=f, args=(queue,)) p.start() print(queue.get()) # prints "[42, None, 'hello']" p.join() ``` #### 线程 (Thread) 线程是进程中可调度运行的一个实体;同一进程下的多个线程共享该进程的所有资源,包括代码段、数据段等,但每个线程有自己的调用栈[^1]。 - **优点** - 启动速度快:相比于进程来说更轻量级。 - 资源消耗少:不需要像启动新进程那样占用大量系统资源。 - **缺点** - 容易受到GIL(Global Interpreter Lock)的影响,在CPU密集型任务上表现不佳。 - 如果某个线程发生异常,则可能会影响到整个程序的安全性和可靠性。 ```python import threading class MyThread(threading.Thread): def run(self): print(f"{threading.current_thread().getName()} started") threads = [] for i in range(5): t = MyThread() threads.append(t) t.start() for thread in threads: thread.join() print("All threads finished execution.") ``` ### 应用场景分析 对于I/O 密集型操作(如文件读写、网络请求),推荐使用多线程来处理,这样可以在等待期间让出 CPU 给其他线程继续工作,从而提高整体性能。 而对于计算密集型的任务(比如大规模数据分析或图像渲染),则更适合采用多进程方案,以充分利用多核处理器的优势并绕过 GIL 的限制。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值