标签搜索

目 录CONTENT

文章目录

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

小小城
2021-08-22 / 0 评论 / 0 点赞 / 5 阅读 / 6,263 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-05-02,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

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

@[toc]

一、自定义进程

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'))
0

评论区