Python中进程的理解
来源:互联网 发布:天堂伞淘宝官方旗舰店 编辑:程序博客网 时间:2024/05/21 12:41
Python中进程的理解:
Num01–>进程的创建-fork
Python的os模块封装了常见的系统调用,其中就包括fork,可以在Python程序中轻松创建子进程。
import os # 注意,fork函数,只在Unix/Linux/Mac上运行,windows不可以 pid = os.fork() if pid == 0: print('我是子进程') else: print('我是父进程') #结果如下: #我是父进程 #我是子进程
以上代码加以说明如下:
程序执行到os.fork()时,操作系统会创建一个新的进程(子进程),然后复制父进程的所有信息到子进程中。
然后父进程和子进程都会从fork()函数中得到一个返回值,在子进程中这个值一定是0,而父进程中是子进程的 id号。
在Unix/Linux操作系统中,提供了一个fork()系统函数,它非常特殊。
普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。子进程永远返回0,而父进程返回子进程的ID。
这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID。
Num02–>多进程修改全局变量
#coding=utf-8import osimport timenum = 0# 注意,fork函数,只在Unix/Linux/Mac上运行,windows不可以pid = os.fork()if pid == 0: num+=1 print('我是子进程---num=%d'%num)else: time.sleep(1) num+=1 print('我是父进程---num=%d'%num) #结果如下: #我是父进程---num=1 #我是子进程---num=1
在多进程中个,每个进程中所有数据(包括全局变量)都各拥有一份,互不影响。
Num03–>多次fork问题
Test01–>fork两次产生四个进程
#coding=utf-8import osimport time# 注意,fork函数,只在Unix/Linux/Mac上运行,windows不可以pid = os.fork()if pid == 0: print('我是第一次fork中的子进程')else: print('我是第一次fork中的父进程')pid = os.fork()if pid == 0: print('我是第二次fork中的子进程')else: print('我是第二次fork中的父进程')time.sleep(1)
Test02–>fork两次产生三个进程
#! /usr/bin/env python3# -*- coding:utf-8 -*- import osimport timedef sing(): print('--我是第一次fork的子进程--') time.sleep(1)def dance(): ppid = os.fork() if ppid > 0: print('--我是第二次fork的父进程--') time.sleep(1) elif ppid == 0: print('--我是第二次fork的子进程--') time.sleep(1)def main(): pid = os.fork() if pid > 0: dance() elif pid == 0: sing()if __name__ == "__main__": main()
Num04–>进程的第一种创建方式-multiprocessing
multiprocessing模块提供了一个Process类来代表一个进程对象。
#coding=utf-8from multiprocessing import Processimport os# 子进程要执行的代码def fun_proc(name): print('子进程运行中,name= %s ,pid=%d' % (name, os.getpid()))if __name__=='__main__': print('父进程 %d' % os.getpid()) p = Process(target=fun_proc, args=('我是子进程',)) print('子进程将要执行') p.start() p.join() print('子进程已结束')# 结果如下:# 父进程 11876# 子进程将要执行# 子进程运行中,name= 我是子进程 ,pid=14644# 子进程已结束
对以上代码加以说明:
1,用Process类创建子进程时,只需要传入一个执行函数和函数的参数(是一个元组)。
2,调用start()方式启动子进程。
3,join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。
Test01–>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值;
Test02–>创建一个进程对象
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Date : 2017-04-25 16:36:47# @Author : xiaokefrom multiprocessing import Processimport osfrom time import sleep# 子进程要执行的代码def fun_proc(name, age, **kwargs): for i in range(5): print('子进程运行中,name= %s,age=%d ,pid=%d...' % (name, age,os.getpid())) print(kwargs) sleep(1)if __name__=='__main__': print('父进程 %d' % os.getpid()) p = Process(target=fun_proc, args=('我是子进程',66), kwargs={"得分":666}) print('子进程将要执行') p.start() sleep(1) # p.terminate()# 提前结束子进程,不管子进程的任务是否完成 p.join() print('子进程已结束')# 结果如下:# 父进程 7744# 子进程将要执行# 子进程运行中,name= 我是子进程,age=66 ,pid=8064...# {'得分': 666}# 子进程运行中,name= 我是子进程,age=66 ,pid=8064...# {'得分': 666}# 子进程运行中,name= 我是子进程,age=66 ,pid=8064...# {'得分': 666}# 子进程运行中,name= 我是子进程,age=66 ,pid=8064...# {'得分': 666}# 子进程运行中,name= 我是子进程,age=66 ,pid=8064...# {'得分': 666}# 子进程已结束
Test03–>创建两个进程对象
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Date : 2017-04-25 16:36:47# @Author : xiaoke#coding=utf-8from multiprocessing import Processimport timeimport osdef 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))def main(): #输出当前程序的ID print("进程ID:%s"%os.getpid()) #创建两个进程对象,target指向这个进程对象要执行的对象名称, #如果不指定name参数,默认的进程对象名称为Process-N,N为一个递增的整数 p1=Process(target=worker_1,args=(2,)) p2=Process(target=worker_2,name="xiaoke",args=(1,)) #使用"进程对象名称.start()"来创建并执行一个子进程, #这两个进程对象在start后,就会分别去执行worker_1和worker_2方法中的内容 p1.start() p2.start() #同时父进程仍然往下执行,如果p2进程还在执行,将会返回True print("p2.is_alive=%s"%p2.is_alive()) print("p1.is_alive=%s"%p1.is_alive()) #输出p1和p2进程的别名和pid print("--p1进程的别名和pid--") print("p1.name=%s"%p1.name) print("p1.pid=%s"%p1.pid) print("--p2进程的别名和pid--") print("p2.name=%s"%p2.name) print("p2.pid=%s"%p2.pid) #join括号中不携带参数,表示父进程在这个位置要等待p1进程执行完成后,再继续执行下面的语句,一般用于进程间的数据同步, # 如果不写这一句,下面的is_alive判断将会是True, #可以尝试着将下面的这条语句改成p1.join(1), #因为p2需要2秒以上才可能执行完成,父进程等待1秒很可能,不能让p1完全执行完成, #所以下面的print会输出True,即p1仍然在执行 print("--p1进程是否执行完毕??--") p1.join() print("p1.is_alive=%s"%p1.is_alive()) p2.join() print("p2.is_alive=%s"%p2.is_alive())if __name__ == '__main__': main()# 结果如下:# 进程ID:4004# p2.is_alive=True# p1.is_alive=True# --p1进程的别名和pid--# p1.name=Process-1# p1.pid=3352# --p2进程的别名和pid--# p2.name=xiaoke# p2.pid=6092# --p1进程是否执行完毕??--# worker_2,父进程(4004),当前进程(6092)# worker_2,执行时间为'1.00'秒# worker_1,父进程(4004),当前进程(3352)# worker_1,执行时间为'2.00'秒# p1.is_alive=False# p2.is_alive=False
Num05–>进程的第二种创建方式–自己创建一个类,继承Process类
定义:创建新的进程还可以使用类的方式。可以自定义一个类,继承Process类。每次实例化这个类的时候,就等同于实例化这个进程对象。
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Date : 2017-04-25 16:36:47# @Author : xiaokefrom multiprocessing import Processimport timeimport 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))# 结果为:# 当前程序进程(14736)# 子进程(4292) 开始执行,父进程为(14736)# 子进程(4292)执行结束,耗时2.00秒# 父进程(14736)执行结束,耗时2.11秒
Num06–>进程池–Pool
当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态生成多个进程。但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。
初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来执行。
#采用非阻塞的方式#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time : 2017/4/27 8:35# @Author : xiaoke# @Site : # @File : Test33.py# @Software: PyCharm Community Editionfrom multiprocessing import Poolimport os, time, randomdef worker(num): t_start = time.time() print("子进程-%s开始执行,进程号为%d" % (num, os.getpid())) # random.random()随机生成0~1之间的浮点数 time.sleep(random.random() * 2) t_stop = time.time() print("子进程-%s执行完毕,耗时%0.2f" % (num, t_stop - t_start))def main(): # 定义一个进程池,最大进程数5 p = Pool(3) for i in range(10): # Pool.apply_async(要调用的目标,(传递给目标的参数元祖,)) # 异步的方式,每次循环将会用空闲出来的子进程去调用目标 p.apply_async(worker, (i,)) m_start = time.time() print("----start----") p.close() # 关闭进程池,关闭后p不再接收新的请求 p.join() # 等待p中所有子进程执行完成,必须放在close语句之后 print("-----end-----") m_stop = time.time() print("父进程执行完毕,耗时%0.2f" % (m_stop - m_start))if __name__ == '__main__': main()# 结果如下:# ----start----# 子进程-0开始执行,进程号为3360# 子进程-1开始执行,进程号为16084# 子进程-2开始执行,进程号为12580# 子进程-1执行完毕,耗时0.05# 子进程-3开始执行,进程号为16084# 子进程-3执行完毕,耗时0.80# 子进程-4开始执行,进程号为16084# 子进程-2执行完毕,耗时1.63# 子进程-5开始执行,进程号为12580# 子进程-0执行完毕,耗时1.80# 子进程-6开始执行,进程号为3360# 子进程-4执行完毕,耗时1.55# 子进程-7开始执行,进程号为16084# 子进程-7执行完毕,耗时0.07# 子进程-8开始执行,进程号为16084# 子进程-8执行完毕,耗时0.05# 子进程-9开始执行,进程号为16084# 子进程-5执行完毕,耗时1.01# 子进程-6执行完毕,耗时1.10# 子进程-9执行完毕,耗时1.57# -----end-----# 父进程执行完毕,耗时4.26
multiprocessing.Pool常用函数解析:
apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表;
apply(func[, args[, kwds]]):使用阻塞方式调用func
close():关闭Pool,使其不再接受新的任务;
terminate():不管任务是否完成,立即终止;
join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;
采用apply阻塞的方式
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time : 2017/4/27 8:35# @Author : xiaoke# @Site : # @File : Test33.py# @Software: PyCharm Community Editionfrom multiprocessing import Poolimport os, time, randomdef worker(num): t_start = time.time() print("子进程-%s开始执行,进程号为%d" % (num, os.getpid())) # random.random()随机生成0~1之间的浮点数 time.sleep(random.random() * 2) t_stop = time.time() print("子进程-%s执行完毕,耗时%0.2f" % (num, t_stop - t_start))def main(): # 定义一个进程池,最大进程数5 p = Pool(3) for i in range(10): # Pool.apply_async(要调用的目标,(传递给目标的参数元祖,)) # 异步的方式,每次循环将会用空闲出来的子进程去调用目标 p.apply(worker, (i,)) m_start = time.time() print("----start----") p.close() # 关闭进程池,关闭后p不再接收新的请求 p.join() # 等待p中所有子进程执行完成,必须放在close语句之后 print("-----end-----") m_stop = time.time() print("父进程执行完毕,耗时%0.2f" % (m_stop - m_start))if __name__ == '__main__': main()# 结果如下:# 子进程-0开始执行,进程号为4464# 子进程-0执行完毕,耗时1.75# 子进程-1开始执行,进程号为11640# 子进程-1执行完毕,耗时1.33# 子进程-2开始执行,进程号为8756# 子进程-2执行完毕,耗时1.86# 子进程-3开始执行,进程号为4464# 子进程-3执行完毕,耗时0.70# 子进程-4开始执行,进程号为11640# 子进程-4执行完毕,耗时1.29# 子进程-5开始执行,进程号为8756# 子进程-5执行完毕,耗时0.69# 子进程-6开始执行,进程号为4464# 子进程-6执行完毕,耗时0.33# 子进程-7开始执行,进程号为11640# 子进程-7执行完毕,耗时1.83# 子进程-8开始执行,进程号为8756# 子进程-8执行完毕,耗时1.58# 子进程-9开始执行,进程号为4464# 子进程-9执行完毕,耗时1.37# ----start----# -----end-----# 父进程执行完毕,耗时0.08
Num07–>进程间的通信–Queue
进程(Process)之间有时间需要通信,操作系统提供了很多机制来实现进程间的通信。如Queue、Pipes等。Queue本身是一个消息队列。
Test01–> 先看一个简单的案例:
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time : 2017/4/27 8:35# @Author : xiaoke# @Site : # @File : Test33.py# @Software: PyCharm Community Editionfrom multiprocessing import Queueq = Queue(3) # 初始化一个Queue对象,最多可接收三条put消息q.put("消息1")q.put("消息2")print(q.full()) # Falseq.put("消息3")print(q.full()) # True# 因为消息列队已满下面的try都会抛出异常,第一个try会等待3秒后再抛出异常,第二个Try会立刻抛出异常try: q.put("消息4", True, 3)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("取出消息:%s" % q.get()) print("取出消息:%s" % 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);
Test02–>在父进程创建两个子进程,一个往Queue里面写数据,一个从Queue里面读数据。
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Time : 2017/4/27 8:35# @Author : xiaoke# @Site : # @File : Test33.py# @Software: PyCharm Community Editionfrom multiprocessing import Process, Queueimport os, time, random# 写数据进程def write(q): for value in ['A', 'B', 'C', 'quit']: 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) # 因为读进程是一个死循环,所以要设置一个标记,用于退出 if value == "quit": break time.sleep(random.random())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() print('所有数据都写入并且读完') print("pw is alive:%s" % pw.is_alive()) print("pr is alive:%s" % pr.is_alive())# 结果如下:# Put A to queue...# Put B to queue...# Put C to queue...# Put quit to queue...# Get A from queue.# Get B from queue.# Get C from queue.# Get quit from queue.# 所有数据都写入并且读完# pw is alive:False# pr is alive:False
Test03–>进程池Pool中的Queue来进行进程间的通信
#!/usr/bin/env python# -*- coding: utf-8 -*-# @Author : xiaoke# @Site : # @File : Test33.py# @Software: PyCharm Community Editionfrom multiprocessing import Pool, Queue, Managerimport osimport timeimport randomdef task_write(q): for s in ('hello', 'python', 'world', 'quit'): q.put(s) # 向队列中添加消息 print('%s 进程向队列中添加消息:%s' % (os.getpid(), s)) time.sleep(random.random() * 2) print('%s 进程要结束了' % os.getpid())def task_read(q): while True: msg = q.get() # 阻塞式从队列中收消息 print('%s 进程从队列中取出消息:%s' % (os.getpid(), msg)) if msg == "quit": break time.sleep(random.random() * 2) print('%s 进程要结束了' % os.getpid())def main(): # 1.创建消息队列对象 # q = Queue() #只能用于父子进程 # Manger().Queue() 消息队列可用于进程池 q = Manager().Queue() # 2.创建进程池,里面放两个进程 my_pool = Pool(2) # 3.添加任务 # 采用阻塞的方式 my_pool.apply(task_write, args=(q,)) my_pool.apply(task_read, args=(q,)) # 采用非阻塞的方式 # my_pool.apply_async(task_write, args=(q,)) # my_pool.apply_async(task_read, args=(q,)) # 4.关闭进程池 my_pool.close() # 5.等待所有进程结束 my_pool.join()if __name__ == "__main__": main()# 采用非阻塞的方式结果:# 7380 进程向队列中添加消息:hello# 11256 进程从队列中取出消息:hello# 7380 进程向队列中添加消息:python# 11256 进程从队列中取出消息:python# 7380 进程向队列中添加消息:world# 11256 进程从队列中取出消息:world# 7380 进程向队列中添加消息:quit# 11256 进程从队列中取出消息:quit# 11256 进程要结束了# 7380 进程要结束了# 采用阻塞的方式结果:# 96 进程向队列中添加消息:hello# 96 进程向队列中添加消息:python# 96 进程向队列中添加消息:world# 96 进程向队列中添加消息:quit# 96 进程要结束了# 12412 进程从队列中取出消息:hello# 12412 进程从队列中取出消息:python# 12412 进程从队列中取出消息:world# 12412 进程从队列中取出消息:quit# 12412 进程要结束了
- Python中进程的理解
- python 进程的理解
- python 中 *\的理解
- python中进程的使用
- Python中理解进程(Process),线程(Thread)和协程(Coroutines)的感悟
- 理解Python进程Process
- Python中self的理解
- Python中yield的理解
- Python中iterator的理解
- Python中self的理解
- Python中self的理解
- Python中切片的理解
- Python中线程的理解
- Python中self的理解
- Python中TFTP的理解
- Python中数据类型的理解
- python 中Counter的理解
- 操作系统中进程概念的理解
- 【STL】模拟实现list
- 详解二叉搜索树
- Graveyard UVALive
- Android 1000实例代码集结(二 )
- tensorflow因为版本,需要修改一些方法问题
- Python中进程的理解
- 5.lvm
- 使用link与@import引入css文件用法区别
- js网页访问的浏览器及移动端的判断
- AndFix的简单使用
- 安装setuptools+pip
- Improving the way neural networks learn
- SQL后台传参
- sql优化部分总结