并发编程之多进程篇之二

Process对象的join方法和其它属性方法

一、Process对象的join方法

　　1、理解：

　　　　在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况：

　　　　情况一：在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，

　　　然后统一回收资源。

　　　　情况二：如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让

　　　主进程检测子进程是否运行完毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用。

　　2、实例：　　　

# join()方法
from multiprocessing import Process
import time,os
def task():
    print('%s is running\t父进程：%s'%(os.getpid(),os.getppid()))#getpid()方法获取当前进程的id号，getppid()获取当前进程父进程的id号
    time.sleep(3)
    print('%s is walking\t父进程：%s'%(os.getpid(),os.getppid()))
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join() # 主进程等待子进程结束，p即为子进程，只有p执行结束了，才能继续向下执行（执行主进程）
    print('主进程:%s\t父进程：%s'%(os.getpid(),os.getppid()))

'''运行结果如下：
7304 is running    父进程：2412
7304 is walking    父进程：2412
主进程:2412   父进程：6232
'''
# 补充：僵尸进程在主进程结束后被回收

　　3、并发执行　

from multiprocessing import Process
import time,os
def task(name,n):
    print('%s is running'%name)
    time.sleep(n)

if __name__ == '__main__':
    start = time.time()
    p1 = Process(target=task,args=('进程1',5))
    p2 = Process(target=task,args=('进程2',4))
    p3 = Process(target=task,args=('进程3',3))

    # p1.start()
    # p2.start()
    # p3.start()
    p_l = [p1,p2,p3]
    for p in p_l:
        p.start()

    # p1.join() #p1结束后再执行p2
    # p2.join() # p2结束后再执行p3
    # p3.join() # p3结束后再继续执行
    for p in p_l:
        p.join()
    print('主进程',os.getpid(),os.getppid(),(time.time()-start))

'''输出：
进程1 is running
进程2 is running
进程3 is running
主进程 5228 6232 5.260061025619507 --> 按照最长的那个进程的时间

'''

　　解析如下：　　　

　　　　进程只要start就会在开始运行了,所以p1-p4.start()时,系统中已经有四个并发的进程了

　　　　而我们p1.join()是在等p1结束,没错p1只要不结束主线程就会一直卡在原地,这也是问题的关键

　　　　join是让主线程等,而p1-p4仍然是并发执行的,p1.join的时候,其余p2,p3,p4仍然在运行,

　　　　等p1.join结束,可能p2,p3,p4早已经结束了,这样p2.join,p3.join.p4.join直接通过检测，

　　　　无需等待所以4个join花费的总时间仍然是耗费时间最长的那个进程运行的时间

　　4、串行执行　　

from multiprocessing import Process
import time,os
def task(name,n):
    print('%s is running'%name)
    time.sleep(n)

if __name__ == '__main__':
    start = time.time()
    p1 = Process(target=task,args=('进程1',5))
    p2 = Process(target=task,args=('进程2',4))
    p3 = Process(target=task,args=('进程3',3))

    p1.start() # 发信号
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()

    print('主进程',(time.time()-start))'''


'''执行结果：
进程1 is running
进程2 is running
进程3 is running
主进程 12.698166608810425 --> 串行执行。时间为进程时间之和
'''

 

二、Process对象的其它属性方法　

# terminate() 发出杀死进程的信号
# is_alive() 查看进程是否还存活着
# 对象.name 查看进程名（未命名时系统自动命名）

　　terminate与is_alive　

from multiprocessing import Process
import time
import random

def task(name):
    print('%s is running' %name)
    time.sleep(random.randrange(1,5))
    print('%s is stop ' %name)

if __name__ == '__main__':
    p1=Process(target=task,args=('cc',))
    p1.start()

    p1.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
    print(p1.is_alive()) #结果为True

    print('主')
    print(p1.is_alive()) #结果为False

　　name与pid

from multiprocessing import Process
import time
import random

def task(name):
    print('%s is running' %name)
    time.sleep(random.randrange(1,5))
    print('%s is stop' %name)

if __name__ == '__main__':
    p1=Process(target=task,args=('cc',),name='子进程1') #可以用关键参数来指定进程名
    p1.start()

    print(p1.name,p1.pid,)

　　综合案例：

import time
from multiprocessing import Process
def talk(name):
    print('%s is talking'%name)
    time.sleep(2)
if __name__ == '__main__':
    p = Process(target=talk,args=('进程1',),name='pro-1')
    p.start()
    p.terminate()
    time.sleep(3)
    print(p.is_alive())
    print('主程序')
    print(p.name)
'''输出：
False
主程序
pro-1 --> 主动命名
# Process-1 --> 自动命名
'''