python多进程编程

进程和线程

• 线程是计算机可以被cpu调度的最小单元；
• 进程是计算机资源分配的最小单元；
• 进程为线程提供资源；

多进程开发

• 进程是计算机中资源分配的最小单元；
• 一个进程可以有有多个线程；
• 同一个进程中的线程共享资源；
• 进程与进程之间是相互隔离的；
• python可以通过多进程利用CPU多核优势，计算密集型操作可以使用多进程提高程序运行效率。

创建多进程

方法一： multiprocessing.Process() 创建多进程

multiprocessing是Python的一个标准模块，它提供了一组用于处理进程的工具。这个模块可以很方便地创建和管理进程。

使用内置模块 multiprocessing.Process() 创建多进程，它接收两个参数：

• 进程函数名，注意不要传入调用。
• 进程函数的参数，以元组的形式传入，若不需要参数可以不指定。

import multiprocessing

def run_task():
    print('hi python')
    
if __name__ == '__main__':
    p = multiprocessing.Process(target=run_task)
    p.start()

import time
import os
import multiprocessing

def run(name):
    print(f'子进程 {name} 开始执行, pid:{os.getpid()}, 父进程 pid:{os.getppid()}')
    time.sleep(2)
    print(f'子进程 {name} 执行结束')
    
if __name__ == '__main__':
    print(f'主进程开始执行, pid:{os.getpid()}')
    process1 = multiprocessing.Process(target=run, args=('process1',))   # 创建子进程1
    process2 = multiprocessing.Process(target=run, args=('process2',))   # 创建子进程2

    process1.start()   # 启动子进程1
    process2.start()   # 启动子进程2

    process1.join()   # 等待子进程1执行完毕
    process2.join()   # 等待子进程2执行完毕

    print(f'主进程执行结束, pid:{os.getpid()}')

• Process.start() 启动子进程
• Process.join() 等待子进程结束（堵塞等待）
• Process.is_alive() 判断子进程是否在运行
• Process.close() 结束子进程

关于进程对象常用的一些方法：

# 创建一个进程
p = multiprocessing.Process(target=func, args=(param,))

# 启动进程
p.start()# 当前进程准备就绪，等待被CPU调用（工作单元其实是进程中的线程）

# 阻塞主进程，等待子进程执行完毕之后才会执行主进程后面的代码
#1.程序执行时，程序本身就是一个进程，叫主进程
#2.手动创建的进程叫子进程
#3.主进程的执行中不会等待子进程执行完毕，就会直接执行后面的代码
p.join() # 等待当前进程的任务执行完毕再向下继续执行


# 将进程设置为守护进程(当主进程退出之后，会直接关闭守护进程)
p.daemon = True # 设置为守护进程，主进程执行完毕后，子进程也自动关闭
p.daemon = False # 设置为非守护进程，主进程等待子进程，子进程执行完毕后，主进程才结束
# 判断进程是否在执行状态，返回 bool
t.is_alive()

# 设置进程名
t.name = 'test_process'

# 获取当前进程编号
os.getpid()

# 获取当前进程的父进程编号
os.getppid()

# cpu的个数, 程序一般创建多个进程（cpu多核优势）
multiprocessing.cpu_count()

方法二：进程池

进程池：

• 可以提供指定数量的进程给用户使用；

• 即当有新的请求提交到进程池中时，如果池未满，则会创建一个新的进程用来执行该请求;反之，如果池中的进程数已经达到规定最大值，那么该请求就会等待；

• 只要池中有进程空闲下来，该请求就能得到执行。

• .提高效率，节省开辟进程和开辟内存空间的时间及销毁进程的时间

• 节省内存空间

Pool.apply() 启动任务（堵塞等待任务完成）
Pool.map() 批量启动任务（堵塞等待任务完成）
Pool.apply_async() 启动任务（非堵塞）
Pool.map_async() 批量启动任务（非堵塞）

from multiprocessing.pool import Pool
from multiprocessing import Process
import time
import os

def run_task(name):
    print("主进程的id{}".format(os.getppid()))
    print("子进程{}的id：{}".format(name, os.getpid()))
    time.sleep(3)
    
if __name__ == '__main__':
    pool = Pool(4)
    for i in range(4):
        name = f"pool_{i}"
        pool.apply_async(run_task, args=(name,))
    
    pool.close()
    pool.join()
    print("执行完毕")

方法三：自定义进程类

通过自定义类来创建多进程，对于这个类有三点要求：

• 必须继承 multiprocessing.Process 这个父类
• 必须重写 run 方法，这个 run 方法里面就是写业务逻辑，在进程 start() 后将会被调用
• 如果有构造函数，必须重载父类的 init 方法

import time
import os
import multiprocessing

class MyProcess(multiprocessing.Process):
    def __init__(self, name):
        # 这里一定要调用父类的初始化函数，否则无法创建进程
        super().__init__()
        self.name = name

    def run(self):
        print(f'子进程 {self.name} 开始执行, pid:{os.getpid()}, 父进程 pid:{os.getppid()}')
        time.sleep(2)
        print(f'子进程 {self.name} 执行结束')
        
if __name__ == '__main__':
    print(f'主进程开始执行, pid:{os.getpid()}')
    process1 = MyProcess('process1')   # 创建子进程1
    process2 = MyProcess('process2')   # 创建子进程2

    process1.start()   # 启动子进程1
    process2.start()   # 启动子进程2

    process1.join()   # 等待子进程1执行完毕
    process2.join()   # 等待子进程2执行完毕

    print(f'主进程执行结束, pid:{os.getpid()}')

进程之间数据共享

• 进程是资源分配的最小单元，每个进程都维护自己独立的数据，不共享。

import multiprocessing

def task(data):
    data.append(0)
    print("子进程", data)
    
if __name__ == "__main__":
    data_list = list()
    p = multiprocessing.Process(target=task, args=(data_list,))
    p.start()
    p.join()
    print("主进程：", data_list)

进程之间的数据共享

进程间通信不能使用线程间通信那种全局变量的方式，因为进程间的数据是相互隔离的，进程间通信一般有三种方式。

使用 multiprocessing.Queue()

import time
from multiprocessing import Process, Queue

def producer(queue):
    print('producer producing goods start')
    for i in range(1, 6):
        queue.put(f'good_{i}')
    print('producer producing goods end')

def consumer(queue):
    goods_name = queue.get()
    print(f'consumer consuming goods: {goods_name} start')
    time.sleep(1)
    print(f'consumer consuming goods: {goods_name} end')

if __name__ == "__main__":
    queue = Queue(10)
    producer_process = Process(target=producer, args=(queue,))
    producer_process.start()

    time.sleep(1)   # sleep 1s 确保生产者先将数据写入队列
    while not queue.empty():
        consumer_process = Process(target=consumer, args=(queue,))
        consumer_process.start()

python 中一共有三个 Queue()

• queue.Queue()
• multiprocessing.Queue()
• multiprocessing.Manager().Queue()

要注意进程间通信使用的是第二个，第一个只能用于线程间通信，而如果是使用进程池创建的进程，则只能用第三个。

pipe()

多个进程间通信可以使用 Queue，而如果只有两个进程，可以使用 Pipe，它只允许一个存一个取，但是它的性能是高于 Queue 的。

from multiprocessing import Process, Pipe

def producer(pipe):
    print('producer producing goods start')
    pipe.send(f'good_1')
    print('producer producing goods end')

def consumer(pipe):
    goods_name = pipe.recv()
    print(f'consumer consuming goods: {goods_name} start')
    time.sleep(1)
    print(f'consumer consuming goods: {goods_name} end')

if __name__ == "__main__":
    print('----主进程开始----')
    s_pipe, r_pipe, = Pipe()
    producer_process = Process(target=producer, args=(s_pipe,))
    consumer_process = Process(target=consumer, args=(r_pipe,))
    producer_process.start()
    consumer_process.start()
    producer_process.join()
    consumer_process.join()
    print('----主进程结束----')

使用 Manager() 共享内存

Manager() 可以创建一个专门用来维护进程间数据共享的进程，它能提供 python 所支持的任何数据结构，也能用来实现进程间的数据通信。

import time
from multiprocessing import Process, Manager


def producer(m_list):
    print('producer producing goods start')
    for i in range(1, 6):
        m_list.append(f'good_{i}')
    print('producer producing goods end')
    

def consumer(m_list):
    while m_list:
        goods_name = m_list.pop()
        print(f'consumer consuming goods: {goods_name} start')
        time.sleep(1)
        print(f'consumer consuming goods: {goods_name} end')
        

if __name__ == "__main__":
    print('----主进程开始----')
    m_list = Manager().list()
    producer_process = Process(target=producer, args=(m_list,))
    consumer_process = Process(target=consumer, args=(m_list,))
    producer_process.start()
    consumer_process.start()
    producer_process.join()
    consumer_process.join()
    print('----主进程结束----')

共享内存的原理：多个进程的虚拟内存会映射到同一块物理内存，多个进程可以共享这一块物理内存的数据，所以多进程可以通过共享内存来共享数据。

但是这里需要注意的是，系统内核不负责多进程对共享内存中数据的修改和访问进行同步，意思是，如果多个进程并发的修改共享内存中的同一个数据，很可能导致数据被错误修改，出现数据不一致的情况。

所以多个进程如果同时操作共享内存中的同一个资源时，需要加锁，且这里加的锁必须是 Manager 共享对象中的锁。

from multiprocessing import Manager,Process

def task1(num, lock):
    for i in range(10000):
        with lock:
            num.value += 1

def task2(num, lock):
    for i in range(10000):
        with lock:
            num.value -= 1
            
if __name__ == "__main__":
    manager = Manager()    # 定义一个共享内存对象
    num = manager.Value("jaye", 7)
    lock = manager.Lock()  # 获取锁
    p1 = Process(target=task1, args=(num, lock))
    p2 = Process(target=task2, args=(num, lock))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(f"主进程的num：{num.value}")