Python之路PythonThread，第二篇，进程2

python3   进程2

僵尸进程处理方法：

3，创建二级子进程处理

4，在父进程中使用信号处理的方法忽略子进程发来的信号；

signal（SIGCHLD，DIG，IGN）

 # 创建二级子进场解决僵尸进程
 import os 

 #创建一级子进程
 pid = os.fork()

 if pid < 0:
     print('create process failed')
 elif pid == 0:
     #创建二级子进程
     p = os.fork()
     if p < 0:
         print('process failed')
     elif p == 0:
         print("做二级子进程任务")
     else:
         #一级子进程退出,使二级子进程成为孤儿
         os._exit(0)
 else:
     #等待一级子进程退出
     os.wait()
     print("做父进程该做的")

更高效的进程创建方法

multiprocessing 模块（标准库模块）

创建的进程的步骤：

1，将要完成的事件封装成一个个函数；

2，使用multiprocessing提供的接口函数创建进程；

3，使新的进程和指定的函数相关联去完成函数中的工作；

4，对进程进行回收处理；

 import multiprocessing as mp
 import os
 import time 

 #将要做的事封装为函数
 def th1():
     print(os.getppid(),"----",os.getpid())
     print('吃饭早饭')
     time.sleep(1)
     print('吃饭午饭')
     time.sleep(2)
     print('吃饭晚饭')
     time.sleep(3)

 def th2():
     print(os.getppid(),"----",os.getpid())
     print("睡午觉")
     time.sleep(1)
     print("睡觉")
     time.sleep(3)

 def th3():
     print(os.getppid(),"----",os.getpid())
     print("打豆豆")
     time.sleep(2)
     print("打豆豆")
     time.sleep(2)

 #创建3个子进程,生成子进程对象
 #将函数和进程进行关联
 p1 = mp.Process(target = th1)
 p2 = mp.Process(target = th2)
 p3 = mp.Process(target = th3)

 #启动进程让其执行对应的函数事件
 #该函数即为这个就进程内容
 p1.start()
 p2.start()
 p3.start()

 print("Parent PID:",os.getpid())

 # 阻塞等对应子进程的退出,然后回收子进程
 p1.join()
 p2.join()
 p3.join()

 print("***********************")
 # th1()
 # th2()
 # th3()

注：1，函数当付给Process的target比那里后函数内容就是对应进程的进程内容，此时函数才有特殊性；

2，多个子进程和父进程之间的执行相互不影响；

创建子进程：

Process() 类

参数： target指定要绑定的函数；

name 给创建的进程起一个名字；

args 需要一个元组，给target指定的函数按位置传参；

kwargs 需要一个字典，给target指定的函数按键值传参；

#进程函数的使用
from multiprocessing import Process
from time import sleep

def worker(sec):
    for i in range(3):
        sleep(sec)
        print("the worker xiaoming")

p = Process(name = 'worker',\
    target = worker,args = (2,),\
    kwargs = {})

p.start()

p.join()

 #进程函数的使用
 from multiprocessing import Process
 from time import sleep

 def worker(sec,msg):
     for i in range(3):
         sleep(sec)
         print("the worker msg",msg)

 p = Process(name = 'worker',\
     target = worker,args = (2,),\
     kwargs = {'msg':'You are a big man'})

 p.start()

 p.join()

 #进程函数的使用
 from multiprocessing import Process
 from time import sleep

 a = 1

 def worker(sec,msg):
     #当worker作为子进程运行时,对全局量a 的修改只会
     #影响在子进程中a的值 ,对父进程没有影响
     global a
     a = 1000
     for i in range(3):
         sleep(sec)
         print("the worker msg",msg)
     print(a)

 p = Process(name = 'worker',\
     target = worker,args = (2,),\
     kwargs = {'msg':'You are a big man'})

 p.start()

 p.join()

 #####
 a=1000

 #进程函数的使用
 from multiprocessing import Process
 from time import sleep

 a = 1

 def worker(sec,msg):
     #当worker作为子进程运行时,对全局量a 的修改只会
     #影响在子进程中a的值 ,对父进程没有影响
     global a
     a = 1000
     for i in range(3):
         sleep(sec)
         print("the worker msg",msg)
     print(a)

 p = Process(name = 'worker',\
     target = worker,args = (2,),\
     kwargs = {'msg':'You are a big man'})

 p.start()

 #进程名称
 print("进程名称:",p.name)
 print("进程PID:",p.pid)
 print('进程状态:',p.is_alive())

 p.join()
 print('parent:',a)

Process() 类 ---->进程对象

属性方法：

print("进程名称", p.name)

print('进程PID',p.pid)

print('进程状态',p.is_alive())

启动子进程

start()

注：start() 时才真正的创建子进程，而不是Process时创建；

回收子进程

join(timeout)

timeout : 设置最长阻塞时间，如果超过这个时间还没有子进程退出，则不再继续等待；

注：内核会帮助应用层记录子进程的退出情况，当使用join函数时，内核会及时返回进程状态给应用层进行处理；

 import multiprocessing as mp
 import os
 import time 

 def th1():
     print(os.getppid(),"----",os.getpid())
     print('吃饭早饭')
     time.sleep(1)
     print('吃饭午饭')
     time.sleep(6)
     print('吃饭晚饭')
     time.sleep(3)

 def th2():
     print(os.getppid(),"----",os.getpid())
     print("睡午觉")
     time.sleep(3)
     print("睡觉")
     time.sleep(3)

 def th3():
     print(os.getppid(),"----",os.getpid())
     print("打豆豆")
     time.sleep(5)
     print("打豆豆")
     time.sleep(2)

 things = [th1,th2,th3]
 process = []

 for th in things:
     p = mp.Process(target = th)
     process.append(p)

 for p in process:
     p.start()

 for i in process:
     i.join(1)

 print("++++++++++++++++++")

p.daemon

默认值为False，表示主进程运行结束后，不会影响子进程的运行，直到子进程运行完，进程才会结束；

如果设置为True， 则主进程运行完毕，则所有子进程也不再运行一起推出；

注：1，该属性的设置必须要在start前

2，该属性的设置并不是讲进程设置为linux、unix中的守护进程；

守护进程： 生命周期长，与前端控制台无关，后台运行，一般用做系统进程或自动化运行进程；

多进程编程：

优点：1，可以并行的执行多个任务，提高运行效率；

2，空间独立，数据方便；

3，创建方便；

缺点：进程的创建和销毁过程需要消耗较多的计算资源；

在需要频繁的创建和删除较多进程的情况下，资源消耗过多，不适宜使用多进程完成任务；

进程池技术：

1，创建进程池，在池内放入合适数量的进程；

2，将时间加入进程池的等待队列；

3，使用进程池内的进程不断的执行等待事件；

4，所有事件处理结束后关闭回收进程池；

 #!/usr/bin/python3

 import multiprocessing as mp
 from time import sleep
 import os

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

 #创建进程池对象,进程池中包含４个进程
 pool = mp.Pool(processes = 4)

 for i in range(10):
     msg = 'hello %d'%i
     #像进程池加入要执行的事件
     pool.apply_async(worker,(msg,))
 #关闭进程池事件加入通道，即不能再向进程池中加入事件
 pool.close()
 #阻塞等待进程池出来事件结束后回收进程池
 pool.join()
 $ python3 pool1.py
 hello 1
 hello 0
 hello 3
 hello 2
 hello 4
 hello 5
 hello 7
 hello 6
 hello 8
 hello 9

Pool ：

功能：创建进程池；

参数： processes 进程池中进程的数量；

apply_async()

功能： 将异步的方式要执行的事件放入进程池；

参数： func  要执行的函数

args   给函数按位置传参

kwds   给函数按照键值传参

返回值： 返回事件执行后的返回值对象，可以通过调用get()函数获取事件函数return的内容；get() 函数获取事件函数return内容；

apply()

功能：按照顺序添加要执行的事件，执行一个添加一个；

close()

功能：关闭进程池，使其不能再加入新的事件；

join()

功能：阻塞等待进程池将事件都执行结束后回收进程池；

 #!/usr/bin/python3

 import multiprocessing as mp
 from time import sleep
 import os

 def worker(msg):
     sleep(2)
     print(msg)
     return 'worker msg' + msg

 #创建进程池对象,进程池中包含４个进程
 pool = mp.Pool(processes = 4)

 result = []
 for i in range(10):
     msg = 'hello %d'%i
     #像进程池加入要执行的事件
     r = pool.apply_async(worker,(msg,))
     #pool.apply(worker,(msg,))
     result.append(r)

 print(result)
 #获取每个事件函数的返回值
 for res in result:
     print(res.get())
 #关闭进程池事件加入通道，即不能再向进程池中加入事件
 pool.close()
 #阻塞等待进程池出来事件结束后回收进程池
 pool.join()

map()

功能： 类似于内建函数map，将第二个参数的迭代对象中的数据逐个带入第一个函数作为参数。只不过兼顾了apply_async功能，将函数放入进程池

pool.map(fun, test)  ====>

for   i in test:

pool.apply_async(fun, (i, ))

 $ cat pool4.py
 #!/usr/bin/python3

 from multiprocessing import Pool
 import time

 def fun(fn):
     time.sleep(1)
     return fn * fn

 test = [1,2,3,4,5,6]

 print('顺序执行:')
 s = time.time()
 #map(fun,test)
 for i in test:
     fun(i)
 e = time.time()
 print('执行时间：',e - s)

 print('进程池执行')
 pool = Pool(processes = 4)
 r = pool.map(fun, test)

 pool.close()

 pool.join()
 print('执行时间:',time.time() - e)
 #####
 $ python3 pool4.py
 顺序执行:
 执行时间： 6.011707782745361
 进程池执行
 执行时间: 2.294673204421997

创建自己的进程类;

1,  继承Process类以获取原有的属性

2，实现自己需要的功能部分；

3，使用自己的类创建进程即可；

 from multiprocessing import Process
 import time

 class ClockProcess(Process):
     def __init__(self, *args, **kwargs):
         Process.__init__(self)
         self.value = value

     #在proces类中实现，现在重写这个函数
     def run(self):
         n = 5
         while n > 0:
             print('The time is {}'.\
                   format(time.ctime()))
             time.sleep(self.value)
             n -= 1

 #s使用自己的进程类创建进程对象
 p = ClockProcess(2)
 #start后会自动执行run函数
 p.start()
 p.join()

进程间的通信：

不同的进程间进行数据的传输；

方法1： 文件进行进程间通信（和磁盘交互慢，不安全）

新的进程间通信方式：

管道  消息队列    共享内存  信号   套接字；

练习1：

 import os 

 #获取文件的大小
 size = os.path.getsize('file')

 #在创建进程前获取文件对象,子进程接受后父子
 #进程使用同一个文件偏移量会造成混乱
 # f = open('file','r')

 pid = os.fork() 

 if pid < 0:
     print("不想动")
 #子进程拷贝前半部分
 elif pid == 0:
     n = size // 2
     fw = open('child','w')
     with open('file','r') as f:
         while True:
             if n < 64:
                 data = f.read(n)
                 fw.write(data)
                 break
             data = f.read(64)
             fw.write(data)
             n -= 64
     fw.close()

 #父进程后半部分
 else:
     fw = open('parent','w')
     with open('file') as f:
         f.seek(size // 2,0)
         while True:
             data = f.read(64)
             if not data:
                 break
             fw.write(data)
     fw.close()