用multiprocessing模块创建进程, 创建自定以进程 ,和进程池技术

• olmultiprocessing 模块创建进程

    1.需要将要执行的事情封装为函数
    2.使用moltiprocessing模块中Process类创建进程对象
    3.通过对象属性设置和Process的初始化函数对进程进行设置,绑定要执行的函数
    4.启动进程,会自动执行进程绑定的函数
    5.完成进程的回收

Process()
    功能:创建进程对象
    参数:name 进程名称  Process-1
             target 绑定函数
             args 元组 给target函数按照位置传参
             kwargs 字典 给target函数按照键值对传参

p.start()
    功能:启动进程
    *target函数会自动执行,此时进程真正被创建
p.join([timeout])
    功能:等待回收子进程
    参数:超时时间

    *使用multiprocessing创建子进程,同样子进程复制父进程的全部代码段
    父子进程各自执行互不影响,父子进程有各自的运行空间

    *如果不使用join回收子进程则子进程退出后会成为僵尸进程

    *使用multiprocessing创建子进程往往父进程只是用来创建进程回收进程
注意:
    1.如果子进程从父进程拷贝对象,对象和网络或者文件相关联,那么父子进程会使用同一套对象属性,相互有一定的关联性
    2.如果在子进程中单独创建对象,则和父进程完全没有关联

# process1.py

from multiprocessing import Process
from time import sleep


# 带参数的进程函数
def worker(sec, name):
    for i in range(3):
        sleep(sec)
        print("I'm %s" % name)
        print("I'm working ..      ..")
p = Process(target = worker, args = (1, 'zhuli'), name = 'shuijun')

p.start()
print('Process name:', p.name)  # 进程名称
print('Process PID', p.pid)     # 获取进程pid号
print('Process is alive:', p.is_alive())  # 进程alive情况
p.join()


#  结果为:
#  Process name: shuijun
#  Process PID 60903
#  Process is alive: True
#  I'm zhuli
#  I'm working ....
#  I'm  zhuli
#  I'm working ....
#  I'm zhuli
#  I'm working ....

Process进程对象属性

    p.start()         启动进程
    p.join()           回收子进程

    p.is_alive()    判断进程的生命周期状态,处于生命周期得到True否则返回False
    p.name          进程名称  默认为Process-1
    p.pid              进程的PID号
    p.daemon
        默认状态False  主进程退出不会影响子进程执行
        如果设置为True,则子进程会随着主进程结束而结束

        *要在srtart 前设置
        *一般不和join一起使用

• 创建自定义进程类

    1.继承Process
    2.编写自己的__init__,同时加载父类的__init__方法
    3.重写run方法,通过生成的对象调用start自动运行

# clock.py
from multiprocessing import Process
import time

class ClockProcess(Process):
    def __init__(self,value):
        self.value = value
        super().__init__()

    # 重写run方法
    def run(self):
        for i in range(5):
            print('The time is {}'.format(time.ctime()))
            time.sleep(self.value)


# 创建自定义进程类的对象
p = ClockProcess(2)
# 自动调用run
p.start()
p.join()

多进程
    优点:可以使用计算机多核,进行任务的并发执行,提高执行效率
        空间独立,数据安全
        运行不受其他进程影响,创建方便
    缺点:进程的创建和消耗的系统资源较多

进程池技术
    产生原因:如果有大量任务需要多进程完成,则可能需要频繁的创建删除进程,给
                     计算机带来较多的资源消耗

    原理:创建适当的进程放入进程池,用来处理待处理事件,处理完毕之后进程不销毁,
             仍然在进程池中等待处理其他事件.进程的复用降低了资源的消耗

    使用方法:
        1.创建进程池,在池内放入适当的进程(4-8个)
        2.将事件加入到进程池等待队列
        3.事件不断取进程执行事件,直到所有事件执行完毕
        4.关闭进程池,回收进程

    Pool(process)
    功能:创建进程池对象
    参数:表示进程池中有多少个进程

    pool.apply_async(func,args,kwargs)
    功能:将事件放入到进程池队列
    参数:func      事件函数
             args       以元组形式给func传参
             kwargs  以字典形式给func传参
    返回值:返回一个代表进程池对象
    pool.close()
    功能:o闭进程池

    pool.join()
    功能:回收进程池

    pool.map(func,iter)
    功能:将要做的事件放入进程池
    参数:func 要执行的函数
             iter    迭代对象
    返回值: 返回事件函数的返回值列表

# pool.py
from multiprocessing import Pool
from time import sleep,ctime


def worker(msg):
    sleep(2)
    print(msg)
    return ctime()

# 创建进程池
pool = Pool(processes = 4)  # 创建4个进程池
result = []
for i in range(10):
    msg = 'hello %d' % i
    # 将事件放入进程池对列中等待执行
    r = pool.apply_async(func = worker, args = (msg,))
    result.append(r)
# 关闭进程池
pool.close()
# 回收进程池
pool.join()
for i in result:
    print(i.get())  #获取事件函数的返回值


# hello 0
# hello 1
# hello 3
# hello 2
# hello 6
# hello 5
# hello 4
# hello 7
# hello 8
# hello 9
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:00 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:02 2018
# Thu Sep 13 20:01:04 2018
# Thu Sep 13 20:01:04 2018