AI智能
改变未来

认识python中的进程


一、程序和进程的区别

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

正在运行着的代码,就称为进程。它除了包含代码以外,还有需要运行的环境等,所以它和程序有所区别

二、进程的创建

  主要有以下几种方式:

  • [li]fork()函数—-(不支持windows系统)
  • 实例化multiprocessing模块中的Process类或其子类(跨平台,适用于子进程数量较少时)
  • 进程池(适用于子进程数量较多时)

[/li]

  1.fork()函数

  在Unix/Linux操作系统中,提供了一个fork()系统函数,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。子进程永远返回0,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID。父进程、子进程执行顺序没有规律,完全取决于操作系统的调度算法

  示例:

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

  2.实例化multiprocessing模块中的Process类或子类

  multiprocessing模块就是跨平台版本的多进程模块,提供了一个Process类来代表一个进程对象。创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动,这样创建进程比fork()还要简单。join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。

  Process语法结构: 

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

  • [li]

    target:表示这个进程实例所调用对象;

  • args:表示调用对象的位置参数元组;

  • kwargs:表示调用对象的关键字参数字典;

  • name:为当前进程实例的别名;

  • group:大多数情况下用不到;

[/li]

  Process类常用方法

  • [li]

    is_alive():判断进程实例是否还在执行;

  • join([timeout]):是否等待进程实例执行结束,或等待多少秒;

  • start():启动进程实例(创建子进程);

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

  • terminate():不管任务是否完成,立即终止;

[/li]

  Process类常用属性:

  • [li]

    name:当前进程实例别名,默认为Process-N,N为从1开始递增的整数;

  • pid:当前进程实例的PID值;

[/li]

  示例1:Process类创建进程

#coding=utf-8from multiprocessing import Processimport 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(\'子进程已结束\')

  示例2:Process子类创建进程

from multiprocessing import Processimport timeimport os#继承Process类class Process_Class(Process):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))

  3.进程池

  当需要创建的子进程数量达到上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束才会执行。需要注意的是,主进程不会主动等待进程池中的所有子进程结束后才结束,需要使用进程池的join()方法来堵塞主进程。

  multiprocessing.Pool常用函数解析:

  • [li]

    apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行),args为传递给func的参数元组,kwds为传递给func的关键字参数字典;

  • apply(func[, args[, kwds]]):使用阻塞方式调用func,必须等待上一个进程退出才能执行下一个进程

  • close():关闭Pool,使其不再接受新的任务;

  • terminate():不管任务是否完成,立即终止;

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

[/li]

  示例1(apply_async非阻塞式):

from multiprocessing import Poolimport os,time,randomdef 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) #定义一个进程池,最大进程数3for i in range(0,10):#以非阻塞的方式向Po中添加任务po.apply_async(worker,(i,))print(\"----start----\")po.close() #关闭进程池,关闭后po不再接收新的请求po.join() #等待po中所有子进程执行完成,必须放在close语句之后print(\"-----end-----\")

  运行结果:

----start----0开始执行,进程号为287681开始执行,进程号为287692开始执行,进程号为287671 执行完毕,耗时0.663开始执行,进程号为287692 执行完毕,耗时1.354开始执行,进程号为287670 执行完毕,耗时1.495开始执行,进程号为287684 执行完毕,耗时0.155 执行完毕,耗时0.653 执行完毕,耗时1.76-----end-----

  示例2:(apply堵塞式)

from multiprocessing import Poolimport os,time,randomdef 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) #定义一个进程池,最大进程数3for i in range(6):#以阻塞的方式向Po中添加任务po.apply(worker,(i,))print(\"----start----\")po.close() #关闭进程池,关闭后po不再接收新的请求print(\"-----end-----\")

  运行结果:

0开始执行,进程号为287820 执行完毕,耗时0.931开始执行,进程号为287811 执行完毕,耗时1.252开始执行,进程号为287832 执行完毕,耗时0.533开始执行,进程号为287823 执行完毕,耗时0.274开始执行,进程号为287814 执行完毕,耗时0.935开始执行,进程号为287835 执行完毕,耗时1.69----start---------end-----

三、进程间通信-Queue

  进程间是不共享数据(包括全局变量)的,但是可以使用multiprocessing模块的Queue实现多进程之间的数据传递,Queue本身是一个消息列队程序(先进先出)。初始化Queue()对象时(例如:q=Queue()),若括号中没有指定最大可接收的消息数量,或数量为负值,那么就代表可接受的消息数量没有上限(直到内存的尽头)。如果要使用Pool创建进程,就需要使用multiprocessing.Manager()中的Queue(),否则就会抛出异常。

  Queue()对象常用方法:

  • [li]qsize():返回当前队列包含的消息数量;
  • empty():如果队列为空,返回True,反之False ;
  • full():如果队列满了,返回True,反之False;
  • get([block[, timeout]]):获取队列中的一条消息,然后将其从列队中移除,block默认值为True;如果block使用默认值,且没有设置timeout(单位秒),消息列队如果为空,此时程序将被阻塞(停在读取状态),直到从消息列队读到消息为止,如果设置了timeout,则会等待timeout秒,若还没读取到任何消息,则抛出\”Queue.Empty\”异常;
  • 如果block值为False,消息列队如果为空,则会立刻抛出\”Queue.Empty\”异常;

[/li]

  • get_nowait():消息列队如果为空,则会立刻抛出\”Queue.Empty\”异常,相当于get(False); 
  • put(item,[block[, timeout]]):将item消息写入队列,block默认值为True;
      如果block使用默认值,且没有设置timeout(单位秒),消息列队如果已经没有空间可写入,此时程序将被阻塞(停在写入状态),直到从消息列队腾出空间为止,如果设置了timeout,则会等待timeout秒,若还没空间,则抛出\”Queue.Full\”异常;
    • 如果block值为False,消息列队如果没有空间可写入,则会立刻抛出\”Queue.Full\”异常;
  • put_nowait():消息列队如果没有空间可写入,则会立刻抛出\”Queue.Full\”异常,相当于put(False)
  •   示例1:

    # coding:utf-8from multiprocessing import Queueq = Queue(3) #创建一个消息队列,能容纳3条消息q.put(\'A\')q.put(\'B\')print(q.full()) #返回Falseq.put(\'C\')print(q.full()) #返回Truetry:q.put(\'D\',timeout=2) #堵塞等待2秒,后抛出异常except:print(\'消息队列已满,现有消息数量%d\'%q.qsize())print(q.get()) #返回A,先进先出# 在写入消息的时候,先判断队列是否已满if not q.full():q.put(\'D\')print(\"还可以写入消息D\")# 在取消息的时候,先判断队列是否为空if not q.empty():for i in range(q.qsize()):print(q.get())

      示例2:在父进程中创建两个子进程,一个往Queue里写数据,一个从Queue里读数据

    # coding:utf-8from multiprocessing import Process,Queuedef worker_write(q):\'\'\'负责写入\'\'\'if not q.full():for i in range(10):q.put(i)print(\"写入数据%s\"%i)def worker_read(q):\'\'\'负责读取\'\'\'if not q.empty():for i in range(q.qsize()):print(\"读取数据%s\"%q.get())def main():q = Queue() #创建消息队列p1 = Process(target=worker_write,args=(q,))p2 = Process(target=worker_read,args=(q,))p1.start() #开启写入子进程p1.join() #等待写入子进程执行完毕p2.start() #开启读取子进程p2.join() #等待读取子进程执行完毕print(\'所有数据都已写入并读取完毕\')if __name__ == \'__main__\':main()

      示例3:进程池中使用Queue

    # coding:utf-8from multiprocessing import Pool,Managerdef worker_write(q):\'\'\'负责写入\'\'\'if not q.full():for i in range(10):q.put(i)print(\"写入数据%s\"%i)def worker_read(q):\'\'\'负责读取\'\'\'if not q.empty():for i in range(q.qsize()):print(\"读取数据%s\"%q.get())def main():q = Manager().Queue() #创建消息队列po = Pool()po.apply(worker_write,args=(q,))# 使用堵塞的方式向Pool中添加任务po.apply(worker_read,args=(q,))po.close()print(\'写入数据并读取数据完毕\')if __name__ == \'__main__\':main()

    赞(0) 打赏
    未经允许不得转载:爱站程序员基地 » 认识python中的进程