欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python高级编程——进程和进程池

程序员文章站 2022-03-03 09:28:59
python提供了一个跨平台的多进程支持——multiprocessing模块,其包含Process类来代表一个进程对象 1、Process语法结构:(注: 传参的时候一定使用关键字传参) 2、自定义进程类:需要继承Process类 自定义类的时候必须注意的事项: 第一,必须继承Process类的构 ......

python提供了一个跨平台的多进程支持——multiprocessing模块,其包含process类来代表一个进程对象

  1、process语法结构:(注: 传参的时候一定使用关键字传参

python高级编程——进程和进程池

 

2、自定义进程类:需要继承process类
       自定义类的时候必须注意的事项:
            第一,必须继承process类的构造方法
            第二,必须重写process类的run()方法
            第三,不能用实例化对象直接调用run()方法,而是调用start()方法
            第四,在进程改变实例化对象的数据时,这个数据是被隔离的,即改变数据不成功
# 自定义进程类
class processclass(process):
    g_num = 100

    def __init__(self, interval):
        # 这行代码必须添加上
        super().__init__()
        self.interval = interval
        self.result = "初始化"

    def run(self):
        global g_num
        g_num = 120
        print("子进程{},开始执行,父进程为{}".format(os.getpid(), os.getppid()))
        start = time.time()
        time.sleep(2)
        stop = time.time()
        print("{}执行结束,耗时{:0.2f}秒".format(os.getpid(), stop-start))
        self.result = "运行之后的结果"


if __name__ == "__main__":
    t_start = time.time()
    print("当前进程{}".format(os.getpid()))
    p = processclass(2)
    p.start()
    p.join()
    t_stop = time.time()
    # 数据隔离
    print("子进程 任务 运行结果:", p.result)   # -----> 初始化 数据未改变
    print(processclass.g_num)    # ------>100  数据未改变
    print("(%s)执行结束,耗时%0.2f" % (os.getpid(), t_stop - t_start))

 

  3、进程间的通信
            像之前改变数据,就要使用到进程间的通信,可以使用multiprocessing模块的queue类来实现进程间的通信
            queue的常用方法:
                 qsize(): 返回当前队列包含的消息(数据)数量
                 empty():如果队列为空,返回true,否则false
                 full():如果队列满了,返回true,否则false
                 get() 或者 put()分别时阻塞式获取 或者 阻塞式存储队列的一条消息(数据),然后获取 或者 添加这条消息,如果队列为空 或者 队列满了,在运行的过程阻塞
                 get_nowait() 或者 put_nowait()分别时非阻塞式获取 或者 非阻塞式存储队列的一条消息(数据),然后移除 和 添加这条消息,如果队列为空 或者 队列满了,会抛出相应的异常

    实例如下:

# 自定义进程类
class processclass(process):
    g_num = 100

    def __init__(self, interval, q):
        # 这行代码必须添加上
        super().__init__()
        self.interval = interval
        self.result = "初始化"
        # 初始化一个队列实例化对象
        self.q = q

    def run(self):
        global g_num
        g_num = 120
        print("子进程{},开始执行,父进程为{}".format(os.getpid(), os.getppid()))
        start = time.time()
        time.sleep(self.interval)
        stop = time.time()
        print("{}执行结束,耗时{:0.2f}秒".format(os.getpid(), stop-start))
        self.result = "运行之后的结果"
        # 将消息(数据)添加到队列中
        self.q.put(g_num)
        self.q.put(self.result)

    def get_data(self):
        return self.result


if __name__ == "__main__":
    # 初始化一个队列实例化对象,参数为队列的长度
    queues = queue(5)
    print("当前进程{}".format(os.getpid()))
    p = processclass(2, queues)
    t_start = time.time()
    p.start()
    p.join()
    t_stop = time.time()
    # 数据隔离
    print("子进程 任务 运行结果:", p.get_data())   # -----> 初始化 数据未改变
    print(processclass.g_num)  # ------>100  数据未改变
    print("子进程 任务 运行结果:", queues.get())  # -----> 120 数据未改变
    print("子进程 任务 运行结果:", queues.get())  # -----> 运行之后的结果 数据未改变
    print("(%s)执行结束,耗时%0.2f" % (os.getpid(), t_stop - t_start))
 
4、进程池:
          如果进程有成千上万个,手动创建进程的工作量巨大,这个时候应该用到multiprocessing模块中的pool类
          这个类下有几个方法比较常用:
          apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行 ,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给 func的参数列表,kwds为传递给func的关键字参数列表;
          apply(func[, args[, kwds]]):使用阻塞方式调用func  close():关闭pool,使其不再接受新的任务; 
           terminate():不管任务是否完成,立即终止;
          join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用
主要实例:
# 进程池
def worker(msg):
    start = time.time()
    print("{}开始执行,进程号为{}".format(msg, os.getpid()))
    # random.random()生成0~1之间的随机数
    time.sleep(random.random()*3)
    # time.sleep(3)
    stop = time.time()
    print(msg, "执行完毕,耗时{:.2f}".format(stop-start))


if __name__ == "__main__":
    # 定义一个进程池,最大数为3
    po = pool(3)
    for i in range(10):
        # 非阻塞式操作pool.apply_async(要调用的目标,(传递给目标的参数元组,))
        # 每次循环将会用空闲出来的子进程去调用目标
        po.apply_async(worker, (i, ))
        # 阻塞式操作
        # po.apply(worker, (i, ))
    print("start".center(24, "-"))
    po.close()
    po.join()
    print("end".center(24, "-"))