python实现进程的三种方式及其区别

时间：2023-03-08 18:04:37
在python中有三种方式用于实现进程
多进程中， 每个进程中所有数据（ 包括全局变量） 都各有拥有⼀份， 互不影响

1.fork()方法

  1. ret = os.fork()
  2. if ret == 0:
  3. #子进程
  4. else:
  5. #父进程

这是python中实现进程最底层的方法，其他两种从根本上也是利用fork()方法来实现的，下面是fork()方法的原理示意图

python实现进程的三种方式及其区别
getpid()、getppid()方法
  1. import os
  2. rpid = os.fork()
  3. if rpid<0:
  4. print("fork调⽤失败。 ")
  5. elif rpid == 0:
  6. print("我是⼦进程（ %s） ， 我的⽗进程是（%s） "%(os.getpid(),os.getppid()))
  7. x+=1
  8. else:
  9. print("我是⽗进程（ %s） ， 我的⼦进程是（ %s） "%(os.getpid(),rpid))
  10. print("⽗⼦进程都可以执⾏这⾥的代码")

运行结果：

  1. 我是⽗进程（ 19360） ， 我的⼦进程是（ 19361）
  2. ⽗⼦进程都可以执⾏这⾥的代码
  3. 我是⼦进程（ 19361） ， 我的⽗进程是（ 19360）
  4. ⽗⼦进程都可以执⾏这⾥的代码
注意:
(1)其中os.fork()的返回值ret在第一行执行后，会开辟另外一个子进程，然后父进程跟子进程同时从此句往下执行，对于子进程来说，ret值是0，对于父进程来说ret值是一个大于0的值，这个值实际上就是新开子进程的pid.
(2)此种开辟进程的方式不会发生堵塞，也就是父进程结束并不会影响子进程的继续执行。实际上是根据操作系统的调度算法来实现的，父子进程相互不影响。
多进程修改全局变量
  1. #coding=utf-8
  2. import os
  3. import time
  4. num = 0
  5. # 注意， fork函数， 只在Unix/Linux/Mac上运⾏， windows不可以
  6. pid = os.fork()
  7. if pid == 0:
  8. num+=1
  9. print('哈哈1---num=%d'%num)
  10. else:
  11. time.sleep(1)
  12. num+=1
  13. print('哈哈2---num=%d'%num)

运行结果

  1. 哈哈1---num=1
  2. 哈哈2---num=1
  3. #多进程不共享全局变量
多次fork()问题
python实现进程的三种方式及其区别
结论：多次fork()会有多个进程生成，生成规则同上。
2，Process方法
python是跨平台的，所以自然肯定会为我们提供实现多进程的库，毕竟在win里面用不了fork()。此方法需要导入对应模块
  1. from multiprocessing import Process
  2. p1=Process(target=xxxx)
  3. p1.start()
这个方法常用场景是使用少量进程做主动服务，如qq客户端，等这样的可以开多个。
还可以继承Process模块并实现run方法来调用，此时xxxx方法等价于run方法执行的内容，在重写过run方法后，在执行子类实例对象的start方法时，会自动调用实现的run方法，这个跟java里面也是类似的。
注意，此种方法子进程不结束，父进程也会堵塞，也就是等子进程都结束后，父进程才会结束，通常应用于进程间的同步。
代码实现演示
  1. #coding=utf-8
  2. from multiprocessing import Process
  3. import os
  4. # ⼦进程要执⾏的代码
  5. def run_proc(name):
  6. print('⼦进程运⾏中， name= %s ,pid=%d...' % (name, os.getpid()))
  7. if __name__=='__main__':
  8. print('⽗进程 %d.' % os.getpid())
  9. p = Process(target=run_proc, args=('test',))
  10. print('⼦进程将要执⾏')
  11. p.start()
  12. p.join()
  13. print('⼦进程已结束')
运行结果
  1. ⽗进程 4857.
  2. ⼦进程将要执⾏
  3. ⼦进程运⾏中， name= test ,pid=4858...
  4. ⼦进程已结束
Process类常⽤⽅法：
is_alive()： 判断进程实例是否还在执⾏；
join([timeout])： 是否等待进程实例执⾏结束， 或等待多少秒；
start()： 启动进程实例（ 创建⼦进程） ；
run()： 如果没有给定target参数， 对这个对象调⽤start()⽅法时， 就将执⾏对象中的run()⽅法；
terminate()： 不管任务是否完成， ⽴即终⽌；
3，利用进程池Pool
当需要创建的⼦进程数量不多时， 可以直接利⽤multiprocessing中的Process动态成⽣多个进程， 但如果是上百甚⾄上千个⽬标， ⼿动的去创建进程的⼯作量巨⼤， 此时就可以⽤到multiprocessing模块提供的Pool⽅法。此方法也需导入对应模块
  1. from multiprocessing import Pool
  2. pool=Pool(3)
  3. pool.apply_async(xxxx)
xxxx表示要在进程中运行的代码块或方法、函数
此方法可以用来做服务器端的响应，往往主进程比较少，而Pool()中的参数值，也就是进程池的大小，真正的任务都在子进程中执行。
使用示例
  1. from multiprocessing import Pool
  2. import os,time,random
  3. def worker(msg):
  4. t_start = time.time()
  5. print("%s开始执⾏,进程号为%d"%(msg,os.getpid()))
  6. #random.random()随机⽣成0~1之间的浮点数
  7. time.sleep(random.random()*2)
  8. t_stop = time.time()
  9. print(msg,"执⾏完毕， 耗时%0.2f"%(t_stop-t_start))
  10. po=Pool(3) #定义⼀个进程池， 最⼤进程数3
  11. for i in range(0,10):
  12. #Pool.apply_async(要调⽤的⽬标,(传递给⽬标的参数元祖,))
  13. #每次循环将会⽤空闲出来的⼦进程去调⽤⽬标
  14. po.apply_async(worker,(i,))
  15. print("----start----")
  16. po.close() #关闭进程池， 关闭后po不再接收新的请求
  17. po.join() #等待po中所有⼦进程执⾏完成， 必须放在close语句之后
  18. print("-----end-----")

运行结果

  1. ----start----
  2. ----start----
  3. 0开始执⾏,进程号为5025
  4. ----start----
  5. 1开始执⾏,进程号为5026
  6. ----start----
  7. ----start----
  8. ----start----
  9. ----start----
  10. ----start----
  11. ----start----
  12. ----start----
  13. 2开始执⾏,进程号为5027
  14. 0 执⾏完毕， 耗时0.58
  15. 3开始执⾏,进程号为5025
  16. 1 执⾏完毕， 耗时0.70
  17. 4开始执⾏,进程号为5026
  18. 2 执⾏完毕， 耗时1.36
  19. 5开始执⾏,进程号为5027
  20. 3 执⾏完毕， 耗时1.03
  21. 6开始执⾏,进程号为5025
  22. 4 执⾏完毕， 耗时1.12
  23. 7开始执⾏,进程号为5026
  24. 5 执⾏完毕， 耗时1.25
  25. 8开始执⾏,进程号为5027
  26. 7 执⾏完毕， 耗时1.28
  27. 9开始执⾏,进程号为5026
  28. 6 执⾏完毕， 耗时1.91
  29. 8 执⾏完毕， 耗时1.23
  30. 9 执⾏完毕， 耗时1.38
  31. -----end-----
上面使用的是非堵塞方法，如果使用aply()，则是堵塞方法
  1. from multiprocessing import Pool
  2. import os,time,random
  3. def worker(msg):
  4. t_start = time.time()
  5. print("%s开始执⾏,进程号为%d"%(msg,os.getpid()))
  6. #random.random()随机⽣成0~1之间的浮点数
  7. time.sleep(random.random()*2)
  8. t_stop = time.time()
  9. print(msg,"执⾏完毕， 耗时%0.2f"%(t_stop-t_start))
  10. po=Pool(3) #定义⼀个进程池， 最⼤进程数3
  11. for i in range(0,10):
  12. po.apply(worker,(i,))
  13. print("----start----")
  14. po.close() #关闭进程池， 关闭后po不再接收新的请求
  15. po.join() #等待po中所有⼦进程执⾏完成， 必须放在close语句之后
  16. print("-----end-----")

运行结果

  1. 0开始执⾏,进程号为5280
  2. 0 执⾏完毕， 耗时0.91
  3. 1开始执⾏,进程号为5281
  4. 1 执⾏完毕， 耗时1.59
  5. 2开始执⾏,进程号为5282
  6. 2 执⾏完毕， 耗时1.25
  7. 3开始执⾏,进程号为5280
  8. 3 执⾏完毕， 耗时0.53
  9. 4开始执⾏,进程号为5281
  10. 4 执⾏完毕， 耗时1.49
  11. 5开始执⾏,进程号为5282
  12. 5 执⾏完毕， 耗时0.18
  13. 6开始执⾏,进程号为5280
  14. 6 执⾏完毕， 耗时1.51
  15. 7开始执⾏,进程号为5281
  16. 7 执⾏完毕， 耗时0.88
  17. 8开始执⾏,进程号为5282
  18. 8 执⾏完毕， 耗时1.08
  19. 9开始执⾏,进程号为5280
  20. 9 执⾏完毕， 耗时0.12
  21. ----start----
  22. -----end-----
multiprocessing.Pool常⽤函数解析：
apply_async(func[, args[, kwds]]) ： 使⽤⾮阻塞⽅式调⽤func（ 并⾏执⾏， 堵塞⽅式必须等待上⼀个进程退出才能执⾏下⼀个进程） ， args为传递给func的参数列表， kwds为传递给func的关键字参数列表；
apply(func[, args[, kwds]])： 使⽤阻塞⽅式调⽤funcclose()： 关闭Pool， 使其不再接受新的任务；
terminate()： 不管任务是否完成， ⽴即终⽌；
join()： 主进程阻塞， 等待⼦进程的退出， 必须在close或terminate之后使⽤；
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.****.net/hu_lichao/article/details/75249055

相关文章