python 进程

其他 2018-05-02 22:13:28 阅读次数: 7

进程的创建-fork

1. 进程 VS 程序

编写完毕的代码，在没有运行的时候，称之为程序

正在运行着的代码，就成为进程

进程，除了包含代码以外，还有需要运行的环境等，所以和程序是有区别的

2. fork( )

Python的os模块封装了常见的系统调用，其中就包括fork，可以在Python程序中轻松创建子进程：

    import os

    # 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
    pid = os.fork()

    if pid == 0:
        print('哈哈1') else: print('哈哈2')

运行结果：

说明：

  • 程序执行到os.fork()时，操作系统会创建一个新的进程（子进程），然后复制父进程的所有信息到子进程中
  • 然后父进程和子进程都会从fork()函数中得到一个返回值，在子进程中这个值一定是0，而父进程中是子进程的 id号

在Unix/Linux操作系统中，提供了一个fork()系统函数，它非常特殊。

普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。

子进程永远返回0，而父进程返回子进程的ID。

这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

3. getpid()、getppid()


import os

rpid = os.fork()
if rpid<0:
    print("fork调用失败。")
elif rpid == 0: print("我是子进程（%s），我的父进程是（%s）"%(os.getpid(),os.getppid())) x+=1 else: print("我是父进程（%s），我的子进程是（%s）"%(os.getpid(),rpid)) print("父子进程都可以执行这里的代码")

运行结果：

我是父进程（19360），我的子进程是（19361）
父子进程都可以执行这里的代码
我是子进程（19361），我的父进程是（19360）
父子进程都可以执行这里的代码

多进程修改全局变量

#coding=utf-8
import os
import time

num = 0

# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以 pid = os.fork() if pid == 0: num+=1 print('哈哈1---num=%d'%num) else: time.sleep(1) num+=1 print('哈哈2---num=%d'%num)

运行结果:

总结：

  • 多进程中，每个进程中所有数据（包括全局变量）都各有拥有一份，互不影响

多次fork问题

如果在一个程序，有2次的fork函数调用，是否就会有3个进程呢？


#coding=utf-8
import os
import time

# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
pid = os.fork()
if pid == 0: print('哈哈1') else: print('哈哈2') pid = os.fork() if pid == 0: print('哈哈3') else: print('哈哈4') time.sleep(1)

运行结果：

说明：

父子进程的执行顺序

父进程、子进程执行顺序没有规律，完全取决于操作系统的调度算法

multiprocessing

如果你打算编写多进程的服务程序，Unix/Linux无疑是正确的选择。由于Windows没有fork调用，难道在Windows上无法用Python编写多进程的程序？

由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。

multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：

#coding=utf-8
from multiprocessing import Process
import os

# 子进程要执行的代码 def run_proc(name): print('子进程运行中，name= %s ,pid=%d...' % (name, os.getpid())) if __name__=='__main__': print('父进程 %d.' % os.getpid()) p = Process(target=run_proc, args=('test',)) print('子进程将要执行') p.start() p.join() print('子进程已结束')

运行结果:

说明

  • 创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。
  • join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

Process语法结构如下：

Process([group [, target [, name [, args [, kwargs]]]]])

  • target：表示这个进程实例所调用对象；

  • args：表示调用对象的位置参数元组；

  • kwargs：表示调用对象的关键字参数字典；

  • name：为当前进程实例的别名；

  • group：大多数情况下用不到；

Process类常用方法：

  • is_alive()：判断进程实例是否还在执行；

  • join([timeout])：是否等待进程实例执行结束，或等待多少秒；

  • start()：启动进程实例（创建子进程）；

  • run()：如果没有给定target参数，对这个对象调用start()方法时，就将执行对象中的run()方法；

  • terminate()：不管任务是否完成，立即终止；

Process类常用属性：

  • name：当前进程实例别名，默认为Process-N，N为从1开始递增的整数；

  • pid：当前进程实例的PID值；

实例1


from multiprocessing import Process
import os
from time import sleep # 子进程要执行的代码 def run_proc(name, age, **kwargs): for i in range(10): print('子进程运行中，name= %s,age=%d ,pid=%d...' % (name, age,os.getpid())) print(kwargs) sleep(0.5) if __name__=='__main__': print('父进程 %d.' % os.getpid()) p = Process(target=run_proc, args=('test',18), kwargs={"m":20}) print('子进程将要执行') p.start() sleep(1) p.terminate() p.join() print('子进程已结束')

运行结果:

父进程 21378.
子进程将要执行
子进程运行中，name= test,age=18 ,pid=21379...
{'m': 20} 子进程运行中，name= test,age=18 ,pid=21379... {'m': 20} 子进程已结束

实例2


#coding=utf-8
from multiprocessing import Process
import time
import os #两个子进程将会调用的两个方法 def worker_1(interval): print("worker_1,父进程(%s),当前进程(%s)"%(os.getppid(),os.getpid())) t_start = time.time() time.sleep(interval) #程序将会被挂起interval秒 t_end = time.time() print("worker_1,执行时间为'%0.2f'秒"%(t_end - t_start)) def worker_2(interval): print("worker_2,父进程(%s),当前进程(%s)"%(os.getppid(),os.getpid())) t_start = time.time() time.sleep(interval) t_end = time.time() print("worker_2,执行时间为'%0.2f'秒"%(t_end - t_start)) #输出当前程序的ID print("进程ID：%s"%os.getpid()) #创建两个进程对象，target指向这个进程对象要执行的对象名称， #args后面的元组中，是要传递给worker_1方法的参数， #因为worker_1方法就一个interval参数，这里传递一个整数2给它， #如果不指定name参数，默认的进程对象名称为Process-N，N为一个递增的整数 p1=Process(target=worker_1,args=(2,)) p2=Process(target=worker_2,name="dongGe",args=(1,)) #使用"进程对象名称.start()"来创建并执行一个子进程， #这两个进程对象在start后，就会分别去执行worker_1和worker_2方法中的内容 p1.start() p2.start() #同时父进程仍然往下执行，如果p2进程还在执行，将会返回True print("p2.is_alive=%s"%p2.is_alive()) #输出p1和p2进程的别名和pid print("p1.name=%s"%p1.name) print("p1.pid=%s"%p1.pid) print("p2.name=%s"%p2.name) print("p2.pid=%s"%p2.pid) #join括号中不携带参数，表示父进程在这个位置要等待p1进程执行完成后， #再继续执行下面的语句，一般用于进程间的数据同步，如果不写这一句， #下面的is_alive判断将会是True，在shell（cmd）里面调用这个程序时 #可以完整的看到这个过程，大家可以尝试着将下面的这条语句改成p1.join(1)， #因为p2需要2秒以上才可能执行完成，父进程等待1秒很可能不能让p1完全执行完成， #所以下面的print会输出True，即p1仍然在执行 p1.join() print("p1.is_alive=%s"%p1.is_alive())

执行结果:


进程ID：19866
p2.is_alive=True
p1.name=Process-1
p1.pid=19867
p2.name=dongGe
p2.pid=19868 worker_1,父进程(19866),当前进程(19867) worker_2,父进程(19866),当前进程(19868) worker_2,执行时间为'1.00'秒 worker_1,执行时间为'2.00'秒 p1.is_alive=False

进程的创建-Process子类

创建新的进程还能够使用类的方式，可以自定义一个类，继承Process类，每次实例化这个类的时候，就等同于实例化一个进程对象，请看下面的实例：

from multiprocessing import Process
import time
import os

#继承Process类 class Process_Class(Process): #因为Process类本身也有__init__方法，这个子类相当于重写了这个方法， #但这样就会带来一个问题，我们并没有完全的初始化一个Process类，所以就不能使用从这个类继承的一些方法和属性， #最好的方法就是将继承类本身传递给Process.__init__方法，完成这些初始化操作 def __init__(self,interval): Process.__init__(self) self.interval = interval #重写了Process类的run()方法 def run(self): print("子进程(%s) 开始执行，父进程为（%s）"%(os.getpid(),os.getppid())) t_start = time.time() time.sleep(self.interval) t_stop = time.time() print("(%s)执行结束，耗时%0.2f秒"%(os.getpid(),t_stop-t_start)) if __name__=="__main__": t_start = time.time() print("当前程序进程(%s)"%os.getpid()) p1 = Process_Class(2) #对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，所以这里会执行p1.run() p1.start() p1.join() t_stop = time.time() print("(%s)执行结束，耗时%0.2f"%(os.getpid(),t_stop-t_start))

进程池Pool

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行，请看下面的实例：

from multiprocessing import Pool
import os,time,random

def worker(msg): t_start = time.time() print("%s开始执行,进程号为%d"%(msg,os.getpid())) #random.random()随机生成0~1之间的浮点数 time.sleep(random.random()*2) t_stop = time.time() print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start)) po=Pool(3) #定义一个进程池，最大进程数3 for i in range(0,10): #Pool.apply_async(要调用的目标,(传递给目标的参数元祖,)) #每次循环将会用空闲出来的子进程去调用目标 po.apply_async(worker,(i,)) print("----start----") po.close() #关闭进程池，关闭后po不再接收新的请求 po.join() #等待po中所有子进程执行完成，必须放在close语句之后 print("-----end-----")

运行结果:

----start----
0开始执行,进程号为21466
1开始执行,进程号为21468
2开始执行,进程号为21467 0 执行完毕，耗时1.01 3开始执行,进程号为21466 2 执行完毕，耗时1.24 4开始执行,进程号为21467 3 执行完毕，耗时0.56 5开始执行,进程号为21466 1 执行完毕，耗时1.68 6开始执行,进程号为21468 4 执行完毕，耗时0.67 7开始执行,进程号为21467 5 执行完毕，耗时0.83 8开始执行,进程号为21466 6 执行完毕，耗时0.75 9开始执行,进程号为21468 7 执行完毕，耗时1.03 8 执行完毕，耗时1.05 9 执行完毕，耗时1.69 -----end-----

multiprocessing.Pool常用函数解析：

  • apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；

  • apply(func[, args[, kwds]])：使用阻塞方式调用func

  • close()：关闭Pool，使其不再接受新的任务；

  • terminate()：不管任务是否完成，立即终止；

  • join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；

apply堵塞式

from multiprocessing import Pool
import os,time,random

def worker(msg): t_start = time.time() print("%s开始执行,进程号为%d"%(msg,os.getpid())) #random.random()随机生成0~1之间的浮点数 time.sleep(random.random()*2) t_stop = time.time() print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start)) po=Pool(3) #定义一个进程池，最大进程数3 for i in range(0,10): po.apply(worker,(i,)) print("----start----") po.close() #关闭进程池，关闭后po不再接收新的请求 po.join() #等待po中所有子进程执行完成，必须放在close语句之后 print("-----end-----")

运行结果:

0开始执行,进程号为21532
0 执行完毕，耗时1.91
1开始执行,进程号为21534 1 执行完毕，耗时1.72 2开始执行,进程号为21533 2 执行完毕，耗时0.50 3开始执行,进程号为21532 3 执行完毕，耗时1.27 4开始执行,进程号为21534 4 执行完毕，耗时1.05 5开始执行,进程号为21533 5 执行完毕，耗时1.60 6开始执行,进程号为21532 6 执行完毕，耗时0.25 7开始执行,进程号为21534 7 执行完毕，耗时0.63 8开始执行,进程号为21533 8 执行完毕，耗时1.21 9开始执行,进程号为21532 9 执行完毕，耗时0.60 ----start---- -----end-----

进程间通信-Queue

Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。

1. Queue的使用

可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序，首先用一个小实例来演示一下Queue的工作原理：


#coding=utf-8
from multiprocessing import Queue
q=Queue(3) #初始化一个Queue对象，最多可接收三条put消息 q.put("消息1") q.put("消息2") print(q.full()) #False q.put("消息3") print(q.full()) #True #因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常 try: q.put("消息4",True,2) except: print("消息列队已满，现有消息数量:%s"%q.qsize()) try: q.put_nowait("消息4") except: print("消息列队已满，现有消息数量:%s"%q.qsize()) #推荐的方式，先判断消息列队是否已满，再写入 if not q.full(): q.put_nowait("消息4") #读取消息时，先判断消息列队是否为空，再读取 if not q.empty(): for i in range(q.qsize()): print(q.get_nowait())

运行结果:


False
True
消息列队已满，现有消息数量:3
消息列队已满，现有消息数量:3
消息1 消息2 消息3

说明

初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；

  • Queue.qsize()：返回当前队列包含的消息数量；

  • Queue.empty()：如果队列为空，返回True，反之False ；

  • Queue.full()：如果队列满了，返回True,反之False；

  • Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；

2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；

  • Queue.get_nowait()：相当Queue.get(False)；

  • Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；

2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；

  • Queue.put_nowait(item)：相当Queue.put(item, False)；

2. Queue实例

我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q): for value in ['A', 'B', 'C']: print 'Put %s to queue...' % value q.put(value) time.sleep(random.random()) # 读数据进程执行的代码: def read(q): while True: if not q.empty(): value = q.get(True) print 'Get %s from queue.' % value time.sleep(random.random()) else: break if __name__=='__main__': # 父进程创建Queue，并传给各个子进程： q = Queue() pw = Process(target=write, args=(q,)) pr = Process(target=read, args=(q,)) # 启动子进程pw，写入: pw.start() # 等待pw结束: pw.join() # 启动子进程pr，读取: pr.start() pr.join() # pr进程里是死循环，无法等待其结束，只能强行终止: print '' print '所有数据都写入并且读完'

运行结果：

3. 进程池中的Queue

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：

RuntimeError: Queue objects should only be shared between processes through inheritance.

下面的实例演示了进程池中的进程如何通信：


#coding=utf-8

#修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random def reader(q): print("reader启动(%s),父进程为(%s)"%(os.getpid(),os.getppid())) for i in range(q.qsize()): print("reader从Queue获取到消息：%s"%q.get(True)) def writer(q): print("writer启动(%s),父进程为(%s)"%(os.getpid(),os.getppid())) for i in "dongGe": q.put(i) if __name__=="__main__": print("(%s) start"%os.getpid()) q=Manager().Queue() #使用Manager中的Queue来初始化 po=Pool() #使用阻塞模式创建进程，这样就不需要在reader中使用死循环了，可以让writer完全执行完成后，再用reader去读取 po.apply(writer,(q,)) po.apply(reader,(q,)) po.close() po.join() print("(%s) End"%os.getpid())

运行结果:


(21156) start
writer启动(21162),父进程为(21156)
reader启动(21162),父进程为(21156) reader从Queue获取到消息：d reader从Queue获取到消息：o reader从Queue获取到消息：n reader从Queue获取到消息：g reader从Queue获取到消息：G reader从Queue获取到消息：e (21156) End

猜你喜欢

转载自www.cnblogs.com/ghming/p/8982803.html
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022