Python中与进程有关的模块

os模块中提供部分函数处理子进程

-----os.fork             #  要求系统创建一个子进程
-----os.getpid           #  获取当前进程的pid
-----os.getppid          #  获取当前进程的父进程的pid

multiprocessing模块

multiprocessing常用组件及功能

1.1、管理进程模块：

• Process（用于创建进程模块）
• Pool（用于创建管理进程池）
• Queue（用于进程通信，资源共享）
• Value，Array（用于进程通信，资源共享）
• Pipe（用于管道通信）
• Manager（用于资源共享）

1.2、同步子进程模块：

• Condition
• Event
• Lock
• RLock
• Semaphore

Process 类

class multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

Process模块用来创建子进程，是Multiprocessing核心模块，使用方式与Threading类似，可以实现多进程的创建，启动，关闭等操作。
一般需要传入target目标函数，args函数的参数

2.1、run（）

   表示进程运行的方法。可以在子类中重写此方法。标准run() 方法调用传递给对象构造函数的可调用对象作为目标参数（如果有），分别使用args和kwargs参数中的顺序和关键字参数。

2.2、start（）

   进程准备就绪，等待CPU调度。

2.3、join（[ 超时] ）

   如果可选参数timeout是None，则该方法将阻塞，直到join()调用其方法的进程终止。如果timeout是一个正数，它最多会阻塞超时秒。请注意，None如果方法的进程终止或方法超时，则返回该方法。检查进程exitcode以确定它是否终止。

2.5、daemon

   进程的守护进程标志，一个布尔值。必须在start()调用之前设置，当进程退出时，它会尝试终止其所有守护进程子进程

multiprocessing.current_process()       #返回一个当前进程的对象

p1 = multiprocessing.Process(target = job)             # 创建一个进程对象
p1.start                         # 运行多进程，执行任务
p1.join()                        # 等待所有子进程执行结束，再执行主进程的内容

---

通过实例化对象来创建多线程

import multiprocessing

def job():
    print("当前子进程的名称为%s"%multiprocessing.current_process())

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=job)     # 创建一个进程对象
    p1.start()          # 运行多进程，执行任务

    p2 = multiprocessing.Process(target=job)
    p2.start()

    p1.join()    # 等待所有的子进程执行结束，再执行主进程内容
    p2.join()
    print("任务执行结束。。。。")

通过继承的方法改写部分内容

import multiprocessing
class JobProcess(multiprocessing.Process):
    # 重写Process的构造方法，获取新的属性
    def __init__(self, queue):
        super(JobProcess, self).__init__()
        '''
        会找到JobProcess的父类，然后把JobProcess对象self转
        换成父类的对象，调用父类的对象自己的构造函数
        '''
        self.queue = queue

    # 重写run方法，将执行的任务放在里面即可
    def run(self):
        print("当前子进程的名称为%s"%(multiprocessing.current_process()))

if __name__ == '__main__':
    processes = []
    for i in range(10):
        p = JobProcess(queue=3)            # 实例化对象
        processes.append(p)
        p.start()      # 启动多线程，处理需要执行的任务

    [process.join() for process in processes]
    print("任务结束。。。。")

进程守护
主进程执行结束，子进程不再继续执行
进程的守护进程标志，一个布尔值。必须在start()调用之前设置，当进程退出时，它会尝试终止其所有守护进程子进程。

p1 = multiprocessing.Process(target = job, name = 'use deamon'
p1.daemon = False
p1.start()

终止进程
p1.terminate()

import time
import  multiprocessing

def job():
    print("start.....")
    time.sleep(1)
    print('end.......')
if __name__ == '__main__':
    p = multiprocessing.Process(target=job)
    print("Before:", p.is_alive())
    p.start()  # 启动子进程
    print("During:", p.is_alive())
    p.terminate()   # 终止子进程
    print('terminate:', p.is_alive())
    p.join()        #等待子进程彻底终止
    print("joined:", p.is_alive())

进程池

  **Multiprocessing.Pool可以提供指定数量的进程供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行它。Pool类用于需要执行的目标很多，而手动限制进程数量又太繁琐时，如果目标少且不用控制进程数量则可以用Process类。**

• processes： 是要使用的工作进程数。如果进程是None，那么使用返回的数字os.cpu_count()。也就是说根据本地的cpu个数决定，processes小于等于本地的cpu个数；
• initializer： 如果initializer是None，那么每一个工作进程在开始的时候会调用initializer(*initargs)。
• maxtasksperchild：工作进程退出之前可以完成的任务数，完成后用一个新的工作进程来替代原进程，来让闲置的资源被释放。maxtasksperchild默认是None，意味着只要Pool存在工作进程就会一直存活。
• context: 用在制定工作进程启动时的上下文，一般使用 multiprocessing.Pool() 或者一个context对象的Pool()方法来创建一个池，两种方法都适当的设置了context。
  实例方法

1.1、apply（func [，args [，kwds ] ] ）

   使用参数args和关键字参数kwds调用func。它会阻塞，直到结果准备就绪。鉴于此块，更适合并行执行工作。此外，func 仅在池中的一个工作程序中执行。

from multiprocessing import Pool
import time
def test(p):
       print (p)
       time.sleep (3)
if __name__=="__main__":
    pool = Pool(processes=10)
    for i  in range(500):
        '''
        ('\n'
         '	（1）遍历500个可迭代对象，往进程池放一个子进程\n'
         '	（2）执行这个子进程，等子进程执行完毕，再往进程池放一个子进程，再执行。（同时只执行一个子进程）\n'
         '	 for循环执行完毕，再执行print函数。\n'
         '	')
        '''
        pool.apply(test, args=(i,))   #维持执行的进程总数为10，当一个进程执行完后启动一个新进程.
    print('test')
    pool.close()
    pool.join()



   for循环内执行的步骤顺序，往进程池中添加一个子进程，执行子进程，等待执行完毕再添加一个子进程……等500个子进程都执行完了，再执行print。（从结果来看，并没有多进程并发）

1.2、apply_async（func [，args [，kwds [，callback [，error_callback ] ] ] ] ）

   异步进程池（非阻塞）,返回结果对象的方法的变体。如果指定了回调，则它应该是可调用的，它接受单个参数。当结果变为就绪时，将对其应用回调，即除非调用失败，在这种情况下将应用error_callback。如果指定了error_callback，那么它应该是一个可调用的，它接受一个参数。如果目标函数失败，则使用异常实例调用error_callback。回调应立即完成，否则处理结果的线程将被阻止。

from multiprocessing import Pool
import time
def test(p):
       print(p)
       time.sleep(3)
if __name__=="__main__":
    pool = Pool(processes=2)
    for i  in range(500):
    '''
     （1）循环遍历，将500个子进程添加到进程池（相对父进程会阻塞）\n'
     （2）每次执行2个子进程，等一个子进程执行完后，立马启动新的子进程。（相对父进程不阻塞）\n'
    '''
    pool.apply_async(test, args=(i,))   #维持执行的进程总数为10，当一个进程执行完后启动一个新进程.
print('test')
pool.close()
pool.join()

调用join之前，先调用close或者terminate方法，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束。