进程三状态

image.png

例子

image.png

开始进程的两种方式

第一种：常用

  1. from multiprocessing import Process
  2. import time
  5. def task(name):
  6.     print('{} is running'.format(name))
  7.     time.sleep(1)
  8.     print('{} is over'.format(name))
  11. if __name__ == '__main__':
  12.     """
  13.     创建进程：
  14.         windows操作系统下， 创建进程一定要在main内创建
  15.         因为windows下创建进程类似于模块导入的方式，会从上到下依次执行代码
  16.         (__main__表示为可执行文件,而非导入，不会进入死循环) 
  17.     """
  19.     # 1. 实例化：创建一个对象。"""args为task函数的参数"""
  20.     p = Process(target=task, args=("wy",))
  21.     # 2. 开启进程
  22.     p.start()  # 告诉操作系统帮你创建一个进程
  23.     print("主进程")
  24.     time.sleep(2)
  25.     print("over")
  27. # 输出
  28. """
  29. 主进程
  30. wy is running
  31. wy is over
  32. over
  33. """

第二种：类的继承

  1. from multiprocessing import Process
  2. import time
  5. class MyProcess(Process):
  6.     def __init__(self, name):
  7.         super(MyProcess, self).__init__()
  8.         self.name = name
  10.     def run(self):
  11.         print('{} is running'.format(self.name))
  12.         time.sleep(1)
  13.         print('{} is over'.format(self.name))
  16. if __name__ == '__main__':
  17.     # 1. 实例化：创建一个对象
  18.     p = MyProcess("wy")
  19.     # 2. 开启进程
  20.     p.start()  # 告诉操作系统帮你创建一个进程
  21.     print("主进程")
  22.     time.sleep(2)
  23.     print("over")

总结

  • 创建进程就是在内存中申请一块内存空间将需要运行的代码放入该内存空间
  • 一个进程对应在内存中就是一块独立的内存空间
  • 多个进程对应在内存中就是对块独立的内存空间

  • 进程与进程之间，数据不共享，如果像共享，需要使用第三方工具、模块

    join方法

  • join：主进程在等待子进程结束后运行

    例子1

    ```python from multiprocessing import Process import time

def task(name, n): print(‘{} is running’.format(name)) time.sleep(n) print(‘{} is over’.format(name))

if name == ‘main‘: “”” 创建进程： windows操作系统下， 创建进程一定要在main内创建 因为windows下创建进程类似于模块导入的方式，会从上到下依次执行代码 (main表示为可执行文件,而非导入，不会进入死循环) “””

  1. # 1. 实例化：创建一个对象。
  2. p1 = Process(target=task, args=("wy", 1))
  3. p2 = Process(target=task, args=("A", 2))
  4. p3 = Process(target=task, args=("C", 3))
  5. start_time = time.time()
  6. # 2. 开启进程
  7. p1.start()  # 告诉操作系统帮你创建一个进程,只是创建了
  8. p2.start()
  9. p3.start()
  11. p1.join()  # join: 主进程等待子进程结束后运行
  12. p2.join()
  13. p3.join()
  15. print("主进程")
  16. print("over")
  17. total_time = time.time() - start_time
  18. print(total_time)

问：total_time大概是多少？

答：结果是3s多，而不是6s多。虽然join的意思是等待子进程结束后主进程再运行。 但是多个子进程是并发运行的，而不是串行，所以不需要等待6s 另外这3个子进程的执行顺序是不固定的(并不知道谁先被创建好)

  1. <a name="ye0Yq"></a>
  2. ## 例子2
  3. ```python
  4. if __name__ == '__main__':
  5.     # 1. 实例化：创建一个对象。
  6.     start_time = time.time()
  7.     for i in range(1, 4):
  8.         p = Process(target=task, args=("第{}个进程".format(i), i))
  9.         # 2. 开启进程
  10.         p.start()
  11.         p.join()
  13.     print("主进程")
  14.     print("over")
  15.     total_time = time.time() - start_time
  16.     print(total_time)
  17. # 问：total_time大概是多少？
  18. 答：结果是6s多。因为for循环时第一个不结束，第二个也不会进入循环

例子3：改进例2的串行

  1. if __name__ == '__main__':
  2.     # 1. 实例化：创建一个对象。
  3.     start_time = time.time()
  4.     p_list = []  # 先放入就绪队列
  5.     for i in range(1, 4):
  6.         p = Process(target=task, args=("第{}个进程".format(i), i))
  7.         # 2. 开启进程
  8.         p.start()
  9.         p_list.append(p)
  10.     for p in p_list:
  11.         p.join()
  13.     print("主进程")
  14.     print("over")
  15.     total_time = time.time() - start_time
  16.     print(total_time) # 3s多

进程之间数据互相隔离

  1. from multiprocessing import Process
  3. money = 100
  6. def task():
  7.     global money  # 将局部变量升为全局变量
  8.     money = 666
  9.     print("子进程：", money)
  12. if __name__ == '__main__':
  13.     p = Process(target=task)
  14.     p.start()
  15.     p.join()
  16.     print("主进程：", money)

进程对象和其他方法

  1. """
  2. 一台计算机上运行着很多进程，计算机是如何区分并管理这些进程服务端的呢？
  3. 每个运行的进程都有一个PID号
  4. 如何查看？
  5. - windows电脑：cmd中输入tasklist即可查看
  6. - windows查找进程号：tasklist | findstr PID
  8. - linux 和 mac :  ps aux
  9. - 查找进程号：ps aux | grep PID
  10. """
  12. #查看当前的进程号
  13. # 方法一
  14. from multiprocessing import current_process
  15. current_process().pid  # 查看当前进程号
  17. # 方法二
  18. import os
  19. os.getpid()  # 查看当前进程号
  20. os.getppid()  # 查看当前进程的父进程号
  22. # 杀死当前进程
  23. p.terminate() # 但是只是告诉操作系统去帮你杀死当前进程，但是需要一定时间，而代码运行速度极快
  24. time.sleep(0.1) # 所有给一点时间
  25. print(p.is_alive())   # 才能真正看起来不存活

进程之间相互通信

  • 需要借助第三方模块
  • 可以用队列(管道+锁)，管道等 ```python from multiprocessing import Process, Queue import time

“”” 进程之间相互通信分两种：

  1. 父进程和子进程之间相互通信
  2. 子进程和子进程之间相互通信 “””

def product(q): q.put(“new params”) # 2. 向队列放参数 print(“hello”)

if name == ‘main‘: q = Queue() # 1. 创建队列 p = Process(target=product, args=(q,)) p.start() print(q.get()) # 3. 从队列中取任务，这里get不需要加join,没有数据就会等待

  1. ```python
  2. from multiprocessing import Process, Queue
  3. import time
  5. def product(q):
  6.     q.put("new params")  # 2. 向队列放参数
  7.     q.put("second")
  8.     print("hello")
  10. def consume(q):
  11.     print(q.get()) # 一个子进程放，一个子进程取
  13. if __name__ == '__main__':
  14.     q = Queue()  # 1. 创建队列
  15.     p = Process(target=product, args=(q,))
  16.     p1 = Process(target=consume, args=(q,))
  17.     p.start()
  18.     p1.start()
  19.     print(q.get())  # 3. 从队列中取任务，这里get不需要加join,没有数据就会等待

parse 模块

  1. import argparse
  2. parser = argparse.ArgumentParser()
  3. parser.add_argument('--foo', help='foo help')
  4. args = parser.parse_args()

https://zhuanlan.zhihu.com/p/526749594

async