多进程的三种实现方式

一、多进程的创建方式

　　1、通过multiprocessing

#encoding='utf-8'
from multiprocessing import Process
import os
import time

'''
os.getpid()
获取一个进程的pid
返回当前进程的pid

os.getppid()
获取父进程的pid
返回父进程的pid
'''


'''
Process类的实例常用的属性和方法有：
name :           当前进程的实例别名，默认为Process-N ,N为从1开始递增的整数
pid:             当前进程实例的pid
is_alive():      判断进程实例是否还在执行
join([timeout]): 是否等待进程实例执行结束，或等待多少秒
start():         启动进程实例（创建子进程）
run():           如果没有给定target参数，对这个对象调用start()方法时，就将执行对象中的run()方法
terminate():     不管任务是否完成，立即终止
'''



def child_1(interval):
    print("子进程（%s）开始执行,父进程为（%s）" %(os.getpid(),os.getppid()))
    t_start = time.time()
    time.sleep(interval)
    t_end = time.time()
    print("子进程（%s）执行时间为'%0.2f'秒" % (os.getpid(),t_end-t_start))

def child_2(interval):
    print("子进程（%s）开始执行,父进程为（%s）" % (os.getpid(), os.getppid()))
    t_start = time.time()
    time.sleep(interval)
    t_end = time.time()
    print("子进程（%s）执行时间为'%0.2f'秒" % (os.getpid(), t_end - t_start))

if __name__ == '__main__':
    print("----父进程开始执行----")
    print("父进程PID：%s" % os.getpid())
    p1 = Process(target=child_1,args=(1,))
    p2 = Process(target=child_1,name="test",args=(2,))
    p1.start()
    p2.start()

    print("p1.is_alive = %s" % p1.is_alive())
    print("p2.is_alive = %s" % p2.is_alive())

    print("p1.name = %s" % p1.name)
    print("p1.pid = %s" % p1.pid)
    print("p2.name = %s" % p2.name)
    print("p2.pid = %s" % p2.pid)

    print("----等待子进程----")
    p1.join()
    p2.join()
    print("----父进程结束---")

　　

　　

　　　　　　　　

 

 

 

　　2、继承Process

　　

#encoding=utf-8
from multiprocessing import Process
import time
import os

class SubProcess(Process):
    def __init__(self, interval, name=''):
        Process.__init__(self)      # 调用父类的初始化方法
        self.interval = interval
        if name:
            self.name = name

    # 重写 run() 方法
    def run(self):
        print("子进程 (%s) 开始执行，父进程为 (%s)" % (os.getpid(), os.getppid()))
        t_start = time.time()
        time.sleep(self.interval)
        t_end = time.time()
        print("子进程 (%s) 执行结束，耗时%0.2f秒" % (os.getpid(), t_end - t_start))

if __name__ == '__main__':
    print("---父进程开始执行---")
    print("父进程 PID: %s" % os.getpid())
    p1 = SubProcess(interval=1, name='test')
    p2 = SubProcess(interval=2)
    p1.start()  # 对一个不包含 target 属性的 Process 类执行 start() 方法，就会运行这个类中的 run() 方法
    p2.start()

    print("p1.is_alive = %s" % p1.is_alive())
    print("p2.is_alive = %s" % p2.is_alive())

    print("p1.name = %s" % p1.name)
    print("p1.pid = %s" % p1.pid)
    print("p2.name = %s" % p2.name)
    print("p2.pid = %s" % p2.pid)

    print("---等待子进程---")
    p1.join()
    p2.join()
    print("---父进程执行结束---")

　　

　　　　　　

 

 　　3、使用进程池 Pool 创建进程

 

　　

#encoding=utf-8
from multiprocessing import Pool
import time
import os


'''
Pool常用方法
apply_async(func[, args[, kwds]]) ： 
    使用非阻塞方式调用 
    func 函数（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），
    args 为传递给 
    func 的参数列表，
    kwds 为传递给 func 的关键字参数列表

apply(func[, args[, kwds]])：
    使用阻塞方式调用 func 函数
    
close() ：
    关闭 Pool，使其不再接受新的任务
    
terminate()：
    不管任务是否完成，立即终止

join()：
    主进程阻塞，等待子进程的退出，必须在 close 或 terminate 之后使用
'''


def task(name):
    print("子进程 (%s) 开始执行 task %s..." % (os.getpid(), name))
    time.sleep(1)       # 休眠 1 秒

if __name__ == '__main__':
    print("---父进程开始执行---")
    print("父进程 PID: %s" % os.getpid())
    p = Pool(3)         # 定义一个进程池，最大进程数为 3
    for i in range(10):
        p.apply_async(task, args=(i,))  # 使用非阻塞方式调用 task() 函数

    print("等待所有子进程结束")
    p.close()
    p.join()
    print("---父进程执行结束---")