Python中的自定义进程和进程池

Python中的自定义进程和进程池

一、自定义进程

1.步骤：

• 继承python的进程类Process
• 重写__init__方法添加自己的属性，使用super()加载父类属性
• 重写run()方法（基类的接口方法，里面什么都没做，就是让子类去重写的）

首先我们按照常规导入multiprocessing模块，同样我们使用 from multiprocessing import Process 语句来导入Process类。Python的多进程运行 要自定义进程，就要重写run()方法。

如果我们我们要自定义一个进程，那么我们就需要在创建我们自己的类时继承父类的Process方法：

class MyProcess(Process):
	def run(self):
		pass

这样我们便完成了进程自定义的结构，Process父类的东西都可以在我们的自定义进程内使用。

2.例

假设我们创建两个进程，循环打印所传入的参数并计数，每执行一次进程加一，我们所需要实现的代码如下：

class MyProcess(Process):
    def run(self):
        n = 1
        while True:
            print('进程名:{} n的值：{}'.format(self.name, n))
            n += 1

每当我们使用start()方法时，系统都会先进入Process类中找run()方法，通过run()方法来启动进程。我们再来添加一个主函数，创建两个进程对象，并将他们添加到进程中：

if __name__ == '__main__':
    p1 = MyProcess(name='李诺')
    p2 = MyProcess(name='夜寒')
    p1.start()
    p2.start()

这是我们运行程序，变发现程序按照我们的需求进行。完整代码：

# 进程：自定义
from multiprocessing import Process


class MyProcess(Process):
    # 重写run()方法

    def run(self):
        n = 1
        while True:
            print('进程名:{} n的值：{}'.format(self.name, n))
            n += 1


if __name__ == '__main__':
    p1 = MyProcess(name='李诺')
    p2 = MyProcess(name='夜寒')
    p1.start()
    p2.start()

from multiprocessing import Process

#自定义类
class MyProcess(Process):

	def __init__(self,value):
		self.value = value
		#自己写__init__(self)会将父类的__init__覆盖，为了不丢失父类的一些属性，需要用super()加载
		super().__init__()

	def f1(self):
		print('步骤1')

	def f2(self):
		print('步骤2')
	
	#run()是Process类专门留出来让你重写的接口函数
	def run(self):
		self.f1()
		self.f2()
		
p = MyProcess(2)
#start()和join()都是从父类中继承过来的
#调用start(）自动执行run(),将f1()和f2()作为子进程执行
p.start()
p.join()

进程池

1.概念

• 在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？
• 首先，创建进程需要消耗时间，销毁进程也需要消耗时间。
• 第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。因此我们不能无限制的根据任务开启或者结束进程。那么我们要怎么做呢？
• 在这里，要给大家介绍一个进程池的概念，定义一个池子，在里面放上固定数量的进程，有需求来了，就拿一个池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务。
• 如果有很多任务需要执行，池中的进程数量不够，任务就要阻塞等待之前的进程执行任务完毕归来，拿到空闲进程才能继续执行。也就是说，池中进程的数量是固定的，那么同一时间最多有固定数量的进程在运行。这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果。

2.介绍——multiprocess.Pool

Pool([numprocess [,initializer [, initargs]]])：创建进程池

参数用法：

numprocess：要创建的进程数，如果省略，将默认使用cpu_count()的值
initializer：是每个工作进程启动时要执行的可调用对象，默认为None
initargs：是要传给initializer的参数组

主要方法：

• p.apply(func [, args [, kwargs]])：在一个池工作进程中执行func(*args,**kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()
• p.apply_async(func [, args [, kwargs]])：**在一个池工作进程中执行func(*args,kwargs),然后返回结果。此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。
• p.close()：关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
• P.join()：等待所有工作进程退出。此方法只能在close()或teminate()之后调用
• obj.get()：返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
• 方法apply_async()和map_async()的返回值是AsyncResul的实例obj。实例具有以下方法：
• obj.ready()：如果调用完成，返回True
• obj.successful()：如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
• obj.wait([timeout])：等待结果变为可用。
• obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

下面我们进程池，当我们需要创建成百上千的进程时，仅仅手动创建则会非常麻烦，于是我们来使用进程池。我们使用 from multiprocessing import Pool 来调用进程池，使用 Pool() 方法来创建进程池，并定义最大进程数。进程池分为阻塞式和非阻塞式。

3.非阻塞式进程池

首先我们需要导入这几个库：

import os
import time
from multiprocessing import Pool
from random import random

首先我们创建一个任务。我们先传入一个任务名，我们使用random和sleep方法来模拟做任务的时间，再使用time来获得做任务的耗时使用os库来获得人物的pid和ppid。最后再返回我们做任务的结果，以下是实现的代码：

def task(task_name):
    start = time.time()
    time.sleep(random() * 2)
    end = time.time()
    return '完成{}，用时：{}，进程ID：{}'.format(task_name, (end-start), os.getpid())

接下来我们再创建主函数，先创建进程池，再创建一个列表，里面添加自己所需的进程。我们使用 pool.apply_async() 来将进程添加到进程池，下面附上实现代码：

if __name__ == '__main__':
    pool = Pool(5)
    tasks = ['听音乐', '打游戏', '洗衣服', '去散步', '去学习', '上厕所', '打代码']
    for i in tasks:
        pool.apply_async(task, args=(i,), callback=call_back)

    pool.close()
    pool.join()
    print('OVER')

其中，pool.close()是表示添加任务结束，需要在添加完任务后在主进程加入此语句。进程池的运行必须要添加pool.join()方法，它可以堵住主进程，使进程池的任务全部执行完成之后才能结束主进程。进程池的运行依赖于主进程，主进程运行完进程池内的任务便会结束，所以添加pool.join()，否则添加完任务后不运行便会结束。

需要回调函数的场景：进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了额，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数

callback 它会将进程（ task() ）的返回值接收，并传入回调函数，回调函数再进行处理。我们定义一个call_back()函数，用来充当callback的参数，实现代码如下：

def call_back(n):
    print(n)

回调函数必须传入参数（上述代码中 n ）我们打印n的值也就是task()的返回值。以下是全部代码：

# 非阻塞式：全部添加到队列中，立即返回，并未等待其他进程执行完毕，但是回调函数等待任务完成后才调用
# 进程池
import os
import time
from multiprocessing import Pool
from random import random

#非阻塞式进程
def task(task_name):
    # print('开始任务：', task_name)
    start = time.time()
    time.sleep(random() * 2)
    end = time.time()
    return '完成{}，用时：{}，进程ID：{}'.format(task_name, (end-start), os.getpid())


def call_back(n):
    print(n)


if __name__ == '__main__':
    pool = Pool(5)
    tasks = ['听音乐', '打游戏', '洗衣服', '去散步', '去学习', '上厕所', '打代码']
    for i in tasks:
        pool.apply_async(task, args=(i,), callback=call_back)

    pool.close()    # 添加表示任务结束
    pool.join()     # 堵住主进程，完成任务之后可继续执行主进程
    print('OVER')

我们添加了七个任务，但进程池只有5个空位。于是系统在添加进程时，未被添加的任务会等待，当其他任务执行完有空位后它在被添加。其中，系统在执行任务时，会从进程池中同时随机选取任务执行，可以看任务名称，不是按列表顺序执行，这便是非阻塞式进程池。

4.阻塞式进程池

**阻塞式进程池只需将 pool.apply_async() 改为 pool.apply() 即可。其中，系统在执行任务时，会按序从进程池中选取任务执行，可以看任务名称， 当第一个任务未执行完时下一个任务不会被执行。这样虽然不会造成任务执行不按序而冲突，但会大大加长任务的执行时间，效率低下。以下附上实现需求的所有代码，这便是阻塞式进程池 。

我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果。

‘’’
特点：
添加一个任务执行一个任务，如果一个任务不结束，另一个任务就进不来

进程池：

 pool = Pool(max)   创建进程池对象
 pool.apply()       阻塞的
 pool.apply_async() 非阻塞的

 pool.close()   执行结束后关闭进程
 pool.join()    让主进程让步

import os
import time
from multiprocessing import Pool
from random import random


# 阻塞式进程
def task(task_name):
    # print('开始任务：', task_name)
    start = time.time()
    time.sleep(random() * 2)
    end = time.time()
    print('完成{}，用时：{}，进程ID：{}'.format(task_name, (end-start), os.getpid()))


def call_back(n):
    print(n)


if __name__ == '__main__':
    pool = Pool(5)
    tasks = ['听音乐', '打游戏', '洗衣服', '去散步', '去学习', '上厕所', '打代码']
    for i in tasks:
        pool.apply(task, args=(i,))

    pool.close()    # 添加表示任务结束
    pool.join()     # 堵住主进程，完成任务之后可继续执行主进程
    print('OVER')

5.例

进程池版socket并发聊天练习：
Server：

#Pool内的进程数默认是cpu核数，假设为4（查看方法os.cpu_count()）
#开启6个客户端，会发现2个客户端处于等待状态
#在每个进程内查看pid，会发现pid使用为4个，即多个客户端公用4个进程
from socket import *
from multiprocessing import Pool
import os

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)

def talk(conn):
    print('进程pid: %s' %os.getpid())
    while True:
        try:
            msg=conn.recv(1024)
            if not msg:break
            conn.send(msg.upper())
        except Exception:
            break

if __name__ == '__main__':
    p=Pool(4)
    while True:
        conn,*_=server.accept()
        p.apply_async(talk,args=(conn,))
        # p.apply(talk,args=(conn,client_addr)) #同步的话，则同一时间只有一个客户端能访问

Client：

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))


while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    msg=client.recv(1024)
    print(msg.decode('utf-8'))