认识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]

　　示例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()