本文阅读时长大约为8分钟。

进程

今日思维导图

练习代码

进程实现多任务

importmultiprocessing

importthreading

deftest1（num）：

foriinrange（num）：

print（＂－－－test1％d＂％i）

deftest2（num）：

foriinrange（num）：

print（＂－－－test2％d＂％i）

defmain（）：

＂＂＂创建子进程只需要把库换成multiprocessing．Proess即可＂＂＂

＃t1＝threading．Thread（target＝test1，args＝（5，））

＃t2＝threading．Thread（target＝test2，args＝（10，））

p1＝multiprocessing．Process（target＝test1，args＝（5，））

p2＝multiprocessing．Process（target＝test2，args＝（10，））

p1．start（）

p2．start（）

if＿＿name＿＿＝＝＇＿＿main＿＿＇：

main（）

获取进程的pid

importmultiprocessing

importos

importtime

＂＂＂

获取进程的pid

os．getpid可以获取当前进程的进程号

os．getppid可以获取当前进程父进程的进程号

＂＂＂

deftest（）：

whileTrue：

print（＂－－当前进程是％s，父进程是％s＂％（os．getpid（），os．getppid（）））

time．sleep（1）

defmain（）：

＃创建进程

p＝multiprocessing．Process（target＝test）

p．start（）

print（＂主程序进程是％s＂％os．getpid（））

pass

if＿＿name＿＿＝＝＇＿＿main＿＿＇：

main（）

进程传递参数

importmultiprocessing

＂＂＂

Process传递的参数可以是多值参数

＊args：代表多值元组

＊＊kwargs：打包多值字典

＂＂＂

deftest（a，＊args，＊＊kwargs）：

print（a）

fornuminargs：

print（num）

print（kwargs）

defmain（）：

p＝multiprocessing．Process（target＝test，args＝（1，2，3，4，5），kwargs＝｛＂name＂：＂xiaohei＂｝）

p．start（）

if＿＿name＿＿＝＝＇＿＿main＿＿＇：

main（）

进程之间不共享全局变量

importos

importtime

importmultiprocessing

＂＂＂

Process语法结构如下：

Process（［group［，target［，name［，args］［，kwargs］］］］）

target：如果传递了函数的引用，可以认为这个子程序就执行这里的代码

args：给target指定的函数传递的参数，已元组的方式传递

kwargs：给target指定的函数传递命名参数，字典

name：给进程设定一个名字，可以不设定

group：指定进程组，大多数情况用不到

Process创建的实例对象的常用方法：

start（）：启动子进程实例（创建子进程）

is＿alive（）：判断进程子进程是否还在活着

join（［timeout］）：是否等待子进程执行完毕，或者等待多少秒

terminate：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性：

name：当前进程的别名，默认为Process－N，N为从1开始递增的整数

pid：当前进程的pid（进程号）ppid（父进程号）

＂＂＂

＃指定一个全局变量

nums＝［1，2，3，4］

deftest（）：

nums．append（5）

print（＂－－在test中nums＝％s＂％nums）

time．sleep（3）

deftest2（）：

print（＂－－在test2中nums＝％s＂％nums）

defmain（）：

print（＂主程序进程是％s，主程序父进程是％s＂％（os．getpid（），os．getppid（）））

＃创建进程

p＝multiprocessing．Process（target＝test）

p．start（）＃启动进程

p．join（1）＃等待子进程执行完毕，可以指定等待的时间

p2＝multiprocessing．Process（target＝test2）

p2．start（）

if＿＿name＿＿＝＝＇＿＿main＿＿＇：

main（）

多进程之间通过Queue队列来共享数据

importmultiprocessing

＂＂＂

一个进程向队列Queue写入数据，另一个进程从队列中获取数据

Queue．put（）：向队列中写入数据

Queue．qsize（）：返回当前队列包含的消息数量

Queue．empty（）：如果队列为空，返回True，反之返回False

Queue．full（）：如果队列满了，返回True，反之False

Queue．get（［block［，timeout］］）：获取队列中的一条消息，然后将其从队列中移除

＂＂＂

deftest1（q）：

＂＂＂下载数据＂＂＂

＃模拟从网上下载数据

data＝［1，2，3，4］

fortempindata：

q．put（temp）＃写入数据

print（＂下载完毕并存入队列中＂）

deftest2（q）：

＂＂＂解析数据＂＂＂

dw＿data＝［］

whileTrue：

data＝q．get（）＃取出并移除数据

dw＿data．append（data）

ifq．empty（）：＃如果队列为空，就退出循环

break

print（dw＿data）

print（＂数据分析完毕＂）

defmain（）：

＃创建队列

q＝multiprocessing．Queue（）

＃创建进程

p1＝multiprocessing．Process（target＝test1，args＝（q，））

p2＝multiprocessing．Process（target＝test2，args＝（q，））

p1．start（）

p2．start（）

if＿＿name＿＿＝＝＇＿＿main＿＿＇：

main（）

进程池

frommultiprocessingimportPool

importtime

importos

importrandom

deftest（i）：

t＿start＝time．time（）＃记录程序开始的时间

print（＂％s开始执行，进程号是％d＂％（i，os．getpid（）））

time．sleep（random．random（）＊2）＃random．random会随机生成0－1之间的浮点数

t＿end＝time．time（）＃记录程序结束的时间

print（＂％s执行完毕，用时％．2f秒＂％（i，（t＿end－t＿start）））

if＿＿name＿＿＝＝＇＿＿main＿＿＇：

try：

po＝Pool（3）＃定义一个进程池，最大进程数为3

foriinrange（0，10）：

＃pool（）．apply＿async（要调用的目标，（传递给目标的参数元组，））

＃每次循环都将会用空闲出来的子进程去调用目标

po．apply＿async（test，（i，））

print（＂开始＂）

po．close（）＃关闭进程池，关闭后po不在接收新的请求

po．join（）＃等待po进程池中所有子进程执行完毕，必须放在close语句之后

print（＂结束＂）

exceptExceptionasresult：

print（result）