关于python:❤️Python从入门到精通二十五Python多进程的使用一看就会❤️

您好，我是码农飞哥，感谢您浏览本文，欢送一键三连哦 。
本篇重点介绍 Python 多过程的应用，读者敌人们能够将多过程和多线程两者做一个比照学习。
干货满满，倡议珍藏，须要用到时常看看。小伙伴们如有问题及须要，欢送踊跃留言哦~ ~ ~。

前言

后面咱们介绍了多线程的应用，这篇文章未来学习多过程的应用。

过程的创立

Python 的 multiprocessing 模块提供了 Process 类，该类可用来在各平台下创立新过程。其构造函数是：

__init__(self, group=None, target=None, name=None, args=(), kwargs={})

其中，各个参数的含意如下：

1. group: 该参数未实现，不须要传参
2. target: 为新建过程指定执行工作，也就是指定一个函数
3. args: 以元组的形式，为 target 指定的办法传递参数，如果传入的是元组中有多个参数的话则传入形式是（arg1,arg2,....argn,）
4. kwargs: 以字典的办法，为 target 指定的办法传递参数。

5. name: 为新建过程设置名称

   一些罕用办法介绍

6. start() 办法用于启动过程
7. run() 办法用于运行所要执行的工作
8. is_alive() 办法用于判断以后过程是否还活着

9. getPid() 办法用于获取过程的 ID 号。

   1. 间接创立 Process 类的实例对象，由此就能够创立一个新的过程；

   这个就相似于间接创立实例化线程 Thread 类

   from multiprocessing import Process
   import os
   # 定义要调用的办法
   def async_fun(name, add):
    for arc in add:
        print(name + str(os.getpid()) + " " + arc)
   
   if __name__ == '__main__':
    my_tuple = ("码农飞哥", "明天是宅家的一天", "30 岁了还没对象焦虑呀")
   
    # 创立过程
    process = Process(target=async_fun, args=("子过程", my_tuple))
    # 启动子过程
    process.start()
    # 启动主过程
    async_fun("主过程", my_tuple)

   运行后果是：

   主过程 11610 码农飞哥
   主过程 11610 明天是宅家的一天
   主过程 11610 30 岁了还没对象焦虑呀
   子过程 11612 码农飞哥
   子过程 11612 明天是宅家的一天
   子过程 11612 30 岁了还没对象焦虑呀

   这里须要留神的一点是，必须要将代码放在 if __name__ == '__main__': 代码块中。通过 os.getpid() 办法来获取过程号。

   2. 通过继承 Process 类的子类，创立实例对象，也能够创立新的过程。

   第二种形式就是通过继承 Process 类的子类，创立实例对象，也能够创立新的过程，不过这种形式须要重写父类的 run()办法。这种办法就相似于间接继承 Thread 类创立线程。

   import multiprocessing
   import os
   
   
   # 定义要调用的办法
   def async_fun(name, add):
    for arc in add:
        print(name + str(os.getpid()) + " " + arc)
   
   
   class MyProcess(multiprocessing.Process):
    def __init__(self, name, add):
        multiprocessing.Process.__init__(self)
        self.add = add
        self.name = name
        # 重写 run()办法
   
    def run(self):
        async_fun(self.name, self.add)
   
   
   if __name__ == '__main__':
    my_tuple = ("码农飞哥", "明天是宅家的一天", "宅家也不能虚度")
    myprocess = MyProcess("子过程", my_tuple)
    myprocess.start()
    # 主过程
    async_fun("主过程", my_tuple)

   运行后果同上。
   这里还是举荐应用 第一种办法创立过程，因为这种形式创立过程比拟简洁

   过程池的应用

   因为创立过程对系统的开销比拟大。所以，所以在理论开发中个别都会应用过程池来创立过程。过程池的应用与线程池的应用也是有神似的中央。同样的在 multiprocessing 模块中提供了 Pool 函数来创立过程池。

   import os
   from multiprocessing import Pool
   import time
   
   
   # 定义要调用的办法
   def async_fun(add):
    time.sleep(1)
    print("过程号：" + str(os.getpid()) + " " + add)
   
   
   if __name__ == '__main__':
    add = "码农飞哥, 明天是宅家的一天,30 岁了还没对象焦虑呀"
    # 创立蕴含 4 个过程的过程池
    pool = Pool(processes=4)
    # 提交 action
    pool.apply_async(func=async_fun, args=(add,))
    pool.apply_async(func=async_fun, args=("加油加油",))
    pool.close()
    pool.join()

   运行后果是：

   过程号：11658 码农飞哥, 明天是宅家的一天,30 岁了还没对象焦虑呀
   过程号：11659 加油加油

   同样的过程池也能够通过 with 语句来创立

   from multiprocessing import Pool
   import os
   import time
   
   
   def async_add(max):
    time.sleep(1)
    print("过程号：" + str(os.getpid()) + "最大值是" + str(max))
   
   
   if __name__ == '__main__':
    with Pool(processes=4) as pool:
        # 应用线程池执行 max 计算
        results = pool.map(async_add, (20, 30, 40, 50))
   

   运行后果是：

   过程号：11726 最大值是 20
   过程号：11725 最大值是 30
   过程号：11727 最大值是 40
   过程号：11728 最大值是 50

   多过程和多线程的优缺点比照

   多过程的长处就是稳定性好，一个子过程解体了，不会影响主过程以及其余子过程，各个子过程各用一套独立的内存空间。多线程的长处就是效率高，实用于批处理等性能。
   多过程的毛病就是创立过程的代价十分大，因为操作系统要给每个过程调配固定的资源，并且操作系统对过程的总数会有肯定的限度，若过程过多，操作系统调度都会存在问题，会造成假死情况。

   总结

   本文具体介绍了 Python 多过程的应用。

   Python 常识图谱

   为了更好帮忙更多的小伙伴对 Python 从入门到精通，我从 CSDN 官网那边搞来了一套《==Python 全栈常识图谱 ==》，尺寸 870mm x 560mm，开展后有一张办公桌大小，也能够折叠成一本书的尺寸，有趣味的小伙伴能够理解一下 —— 扫描下图中的二维码即可购买。

我自己也曾经用上了，感觉十分好用。图谱桌上放，常识心中留。

我是码农飞哥，再次感谢您读完本文 。
全网同名【码农飞哥】。不积跬步，无以至千里，享受分享的高兴
我是码农飞哥，再次感谢您读完本文。