亲宝软件园·资讯

展开

python异步任务

colourmind 人气:0

写在最前面,说实话python多进程这块儿知识对于很少使用python多进程或者没有实际使用过多python进程解决问题的人来说,还是有一定难度的。本人也是很少接触多进程的场景,对于python多进程的使用也是比较陌生的。在接触了一些多进程的业务场景下,对python多进程的使用进行了学习,觉得很有必要进行一个梳理总结。

一、python多进程及通信基本用法

python中多进程及其通信,是比较重要的一块儿内容,作为python程序员,这块儿内容要基本掌握。

1、多进程的基本实现

python多进程的使用一般是调用multiprocessing包中的Process和Pool(进程池),其中Process的用法又有多种,基本函数

p.start()启动一个已经初始化的进程

p.join()让进程运行完了以后,主进程再执行

a、Process重写run方法

MultiOneProcess类继承了multiprocessing的Process类,然后重写它的run方法,实现具体业务逻辑功能;主程序启动10个进程。

from multiprocessing import Process
count = 0
class MultiOneProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self) -> None:
        global count
        count += 1
        print('process name %s is running----count:%d'%(self.name, count))
if __name__ == '__main__':
    p_list = []
    for i in range(10):
        name = 'process_%d'%i
        p = MultiOneProcess(name = name)
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('this main process')

 b、使用Process和target方法

定义一个进程类继承Process类,同时在super()初始化中传入target函数

from multiprocessing import Process
count = 0
class MultiTwoProcess(Process):
    def __init__(self,name):
        super().__init__(target=self.do_fun)
        self.name = name
    def do_fun(self):
        global count
        count += 1
        print('process name %s is running----count:%d' % (name, count))
if __name__ == '__main__':
    p_list = []
    for i in range(10):
        name = 'process_%d'%i
        p = MultiTwoProcess(name)
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('this main process')

代码中定义了一个类MultiTwoProcess类,类中定义了do_fun函数,把它作为参数传入到target中。

c、直接使用Process类

传入target函数,同时传入args参数,注意args参数是一个元组,切不能省略最后一个逗号

from multiprocessing import Process
count = 0
def do_fun(name):
    global count
    count += 1
    print('process name %s is running----count:%d' % (name, count))
 
if __name__ == '__main__':
    p_list = []
    for i in range(10):
        name = 'process_%d'%i
        p = Process(target=do_fun,args=(name,))
        p.start()
        p_list.append(p)
 
    for p in p_list:
        p.join()
    print('this main process')

以上三者运行的结果,是一样的,如下:

2、多进程的通信

进程之间的通信一般都采用Queue和pipe,区别是:pipe只能在两个进程之间调用,而Queue是可以多个进程间调用的;效率上pipe效率更高,Queue是基于pipe实现的,效率比pipe要低一点。

a、Queue

常用API,

存放数据

queue.put(obj, block=True, timeout=None)

当block=False的时候,如果Queue已经满了,那么就会跑出Queue.Full异常;

当block=True且timeout有正值的时候,Queue已经满了,Queue会阻塞timeout时间,超出时间就会抛出同样的异常

获取数据

queue.get(block=True, timeout=None)

当block=False的时候,如果Queue为空,那么就会跑出Queue.Empty异常;

当block=True且timeout有正值的时候,Queue已经为空,Queue会阻塞timeout时间,超出时间就会抛出同样的异常

以上2个API是阻塞;还有两个非堵塞的API

queue.put(obj, block=False) 和 queue.put_nowait(obj)等效

queue.get(block=False) 和 queue.get_nowait()等效

简单的实现,一个进程发送数据,另外2个进程接收数据,就可以使用queue通信

from multiprocessing import Process, Queue
def send(q):
    while True:
        q.put('发送一个数据')
def receive1(q):
    while True:
        s = q.get()
        print('receive1:', s)
def receive2(q):
    while True:
        s = q.get()
        print('receive2:', s)
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=send,args=(q,))
    p2 = Process(target=receive1,args=(q,))
    p3 = Process(target=receive2,args=(q,))
    p1.start()
    p2.start()
    p3.start()

p1进程不断的往q中存放数据;p2和p3不停的从q中取数据(有竞争的再取),所以打印结果是无序的

 b、Pipe

Pipe(duplex=True)返回2个连通端(p1,p2);当duplex=True时,双向通信,p1发送,p2接收;p2发送,p1接收。

当duplex=True时,单向通信,p1只能发送,p2只能接收。

常用API, pipe.send()  pipe.recv()

from multiprocessing import Process, Pipe
def fun2(p):
    while True:
        s = p.recv()
        print('接收一个数据:',s)
def fun1(p):
    while True:
        print('发送一个数据:pipe')
        p.send('pipe')
if __name__ == '__main__':
    pi1,pi2 = Pipe(duplex=True)
    p1 = Process(target=fun1,args=(pi1,))
    p2 = Process(target=fun2,args=(pi2,))
    p1.start()
    p2.start()

结果如下:

二、python多进程实战

不同的业务场景使用多进程的方式和复杂度也不相同,就我遇见过的一些场景进行演示和说明。

1、使用进程池快速抽取数据

场景描述:有1000个Excel文件的数据需要进行抽取和清洗,要把不符合我们需求的数据过滤掉,保留质量很高的数据;每个Excel都有几十万或者上百万的数据,那么怎么快速的完成这个任务呢?

首先整体上而言,可以把单个Excel的处理并行起来;那么可以使用多进程,其次这个需要返回结果,要保留合格的数据,比较简单的就是采用进程池了,它能够很方便的把进程处理的结果进行返回,并且返回的还是一个生成器;如果还需要更快,那么可以把单个Excel中的每条数据的处理并行起来。代码层面上,采用pool进程池来完成这个任务(本文没有对进程池的使用和API做说明),具体的实现方式采取pool.imap()

if __name__ == '__main__':
    #所有Excel的路径
    all_paths = glob('../data/original_data/*')
    sysInfo_list = ['我通过了好友请求,现在你俩可以开始聊天了', '我通过了你的朋友验证请求,现在我们可以开始聊天了', '已通过你的朋友验证请求,现在可以开始聊天了', '不支持此消息,请在手机上查看',
                    '微信红包']
    interval = 25
    if len(all_paths)//interval * interval < len(all_paths):
        k = len(all_paths)//interval + 1
    else:
        k = len(all_paths) // interval
    #分段处理,每段25个Excel
    for i in range(k):
        paths = all_paths[i*interval:(i+1)*interval]
        if i*interval >= 100 and i*interval < 200:
            params = []
            for path in tqdm(paths):
                params.append((path, sysInfo_list))
            #多进程处理——进程池、以及进度显示
            with Pool(20) as p:
                res = list(tqdm(p.imap(extract_data, params), total=len(params), desc='extract_data'))
            all_df = []
            for dfs in res:
                if len(dfs) > 0:
                    all_df.extend(dfs)
            df = pd.concat(all_df, axis=0)
            save_path = '../data/weikong_clean_data_'+str(i*interval)+'_'+str(i*interval+len(paths)-1)+'.xlsx'
            writer = pd.ExcelWriter(save_path)
            df.to_excel(writer, index=False)
            writer.save()
            writer.close()

2、多进程及通信完成数据清洗和保存

场景描述:从Excel中读取数据,数据格式是整通整通的对话,每通对话有一定的轮数;保存数据到2个txt中,一个是顺序保留,一个是倒序保留;整体对话顺序不变,每通对话内部顺序倒序。

正序:

 倒序:

 要想实现这样的任务,粗暴的做法是,用两个list,一个保留正序的,一个保留倒序的,然后分别对这两个list进行文件写入操作。但是如果数据量很多在内存有限的时候,只能满足不了两个list的情况下怎么实现呢?

我的实现方式就是开启两个进程,一个进程保留一个正序list,写入文件的同时对每个元素(每通)对话进行倒序,然后把倒序后的数据通过Queue或者Pipe传入到另外一个进程,让另外的进程进行写文件操作。

def save_mmi_train_data(queue):
    with open('../data/finetune_mmi_data/train.txt','w',encoding='utf-8') as f:
        while True:
            save_list = queue.get()
            if len(save_list) == 0:
                break
            for line in save_list:
                f.write(line)
def save_mmi_val_data(queue):
    with open('../data/finetune_mmi_data/val.txt','w',encoding='utf-8') as f:
        while True:
            save_list = queue.get()
            if len(save_list) == 0:
                break
            for line in save_list:
                f.write(line)
def get_funtine_data(paths):
    all_groups = []
    for path in tqdm(paths,desc='load data from excle'):
        df = pd.read_excel(path)
        df.dropna(inplace=True)
        df.drop_duplicates(inplace=True, keep='first')
        groups = list(df.groupby(by=['坐席id', '客户微信id']))
        all_groups.extend(groups)
    print('len(all_groups)',len(all_groups))
    train, val = train_test_split(all_groups,test_size=10000/len(all_groups),random_state=1)
    print('len(train)', len(train))
    print('len(val)', len(val))
    train_std_path = '../data/finetune_std_data/train.txt'
    val_std_path = '../data/finetune_std_data/val.txt'
    train_mmi_queue = Queue()
    save_funtine_data(train, train_std_path,train_mmi_queue,save_mmi_train_data)
    val_mmi_queue = Queue()
    save_funtine_data(val, val_std_path, val_mmi_queue, save_mmi_val_data)
def save_funtine_data(groups,save_std_path,queue,fun):
    p = Process(target=fun,args=(queue,))
    p.start()
    with open(save_std_path,'w', encoding='utf-8') as f:
        for group in tqdm(groups, desc='find and save funtine dialogue datas'):
            new_df = group[1]
            df_roles = new_df['是否客服'].values.tolist()
            df_contents = new_df['消息内容'].values.tolist()
            roles = []
            contents = []
            for role,content in zip(df_roles,df_contents):
                content = content.replace('\n', '')
                content = emoji.replace_emoji(content, '')
                if len(content) > 0 and content != "":
                    roles.append(role)
                    contents.append(content)
            save_list = []
            save_str = ""
            for index, role in enumerate(roles):
                content = contents[index].replace('\n','')
                content = emoji.replace_emoji(content, '')
                if content[-1] not in punctuations:
                    content += ';'
                if index == 0:
                    if role == "是":
                        save_str += "坐席:"+content
                    else:
                        save_str += "客户:"+content
                else:
                    if role != roles[index-1]:
                        f.write(save_str[0:-1]+'\n')
                        save_list.append(save_str[0:-1]+'\n')
                        if role == "是":
                            save_str = "坐席:" + content
                        else:
                            save_str = "客户:" + content
                    else:
                        save_str += content
            if len(save_str) > 1:
                save_list.append(save_str[0:-1] + '\n')
                f.write(save_str[0:-1]+'\n')
            f.write('\n')
            # 切片反转
            save_list = save_list[::-1]
            save_list.append('\n')
            if len(save_list) > 0:
                queue.put(save_list)
    #注意传入一个空值,让倒序进程结束
    queue.put([])
    p.join()

要注意的是,倒序进程中使用while True 无限循环,需要传入一个空值,能够让它在正序进程结束的同时知道数据写完了,跳出循环。以上代码比较简单就不一一说明了。

3、多进程及通信实现异步任务需求

场景描述:假定一个模型推理系统,网络模块负责接受请求传输的数据,把数据传输给数据处理模块;数据处理模块负责处理数据(比如说语音流或者视频流等,这些数据处理对CPU的消耗很大),处理完后把数据传输给模型推理模块;模型推理模块负责对数据进行推理并把结果返回给网络模块。要求就是网络模块、数据处理模块和模型推理模块是独立的,可以并行的完成自己的任务,3个模块是异步的,其实可以把这个系统简化的使用多进程来实现。

每个模块可以用一个进程来表示,内部的逻辑可以开启子进程来实现,然后模块直接的数据传输就可以使用多进程的通信来实现,同时也创建一个全局的Queue变量,让每个模块的进程按需使用。

画了一个简单的结构和流程图,如下:

 注意的是模块之间的数据传输,使用queue传输的时候,数据量越小,效率越高,所以可以在网络模块这端提前把数据进行处理。

函数入口文件

import a
import b
import c
from whole_queue import WholeQueue
import os
if __name__ == '__main__':
    print("main process:",os.getpid())
 
    whole_queue = WholeQueue()
    b_pool_size = 2
    c_pool_size = 6
    Module_list = [
        a.A(whole_queue,b_pool_size),
        b.B(whole_queue,b_pool_size,c_pool_size),
        c.C(whole_queue,c_pool_size)
    ]
 
    for p in Module_list:
        p.start()

公共队列类

class WholeQueue():
    def __init__(self):
        self.queues = dict()
    def register(self,queuename,queue):
        self.queues[queuename] =  queue

各个子模块类

a

from multiprocessing import Process,Queue
import time
import random
import os
class A(Process):
    def __init__(self,whole_queue,b_pool_size):
        super().__init__(target=self.do_run)
        self.whole_queue = whole_queue
        self.b_pool_size = b_pool_size
        self.queue_list = []
        queue = Queue()
        self.whole_queue.register('A', queue)
        self.queue_list.append(queue)
        self.count  = 0
    def do_run(self):
        print("A.do_run process:", os.getpid())
        a_send_pro = Process(target = self.send)
        a_send_pro.start()
        a_receive_pro = Process(target = self.receive)
        a_receive_pro.start()
    def send(self):
        print("A.send process:", os.getpid())
        while True:
            time.sleep(0.001)
            self.whole_queue.queues['B_%d'%(self.count%self.b_pool_size)].put_nowait(self.count)
            self.count += 1
    def receive(self):
        print("A.receive process:", os.getpid())
        while True:
            rece = self.whole_queue.queues['A'].get()
            print(rece)
 

b

from multiprocessing import Process,Queue
import time
import random
import os
class B(Process):
    def __init__(self,whole_queue,b_pool_size,c_pool_size):
        super().__init__(target=self.do_run)
        self.whole_queue = whole_queue
        self.b_pool_size = b_pool_size
        self.c_pool_size = c_pool_size
        self.queue_list = []
        for i in range(self.b_pool_size):
            queue = Queue()
            self.whole_queue.register('B_%d'% i , queue)
            self.queue_list.append(queue)
        self.count  = 0
    def do_run(self):
        print("B.do_run process:", os.getpid())
        for i in range(self.b_pool_size):
            p = Process(target=self.component,args=(self.queue_list[i],))
            p.start()
    def component(self, queue):
        print("B.component process:", os.getpid())
        while True:
            time.sleep(0.01)
            info = queue.get()
            componext_info = 'component_' + str(info)
            self.whole_queue.queues['C_%d'%(info%self.c_pool_size)].put(componext_info)

c

from multiprocessing import Process,Queue
from model import Model
import time
import random
import os
class C(Process):
    def __init__(self,whole_queue,c_pool_size):
        super().__init__(target=self.do_run)
        self.whole_queue = whole_queue
        self.c_pool_size = c_pool_size
        self.queue_list = []
        for i in range(self.c_pool_size):
            queue = Queue()
            self.whole_queue.register('C_%d'% i , queue)
            self.queue_list.append(queue)
        # self.cache_queue = None
        # self.result_queue = None
        # self.infer_queue = None
    def do_run(self):
        cache_queue = Queue()
        result_queue = Queue()
        infer_queue = Queue()
        print("C.do_run process:", os.getpid())
        for i in range(self.c_pool_size):
            p = Process(target=self.receive,args=(self.queue_list[i], cache_queue,))
            p.start()
        cache_p = Process(target=self.cache,args=(cache_queue, infer_queue,))
        cache_p.start()
        predict_p = Process(target=self.predict,args=(infer_queue, result_queue))
        predict_p.start()
        while True:
            res = result_queue.get()
            for ele in res:
                self.whole_queue.queues['A'].put(ele)
    def receive(self, queue,cache_queue):
        print("C.receive process:", os.getpid())
        while True:
            info = queue.get()
            receive_info = 'receive_' + info
            cache_queue.put(receive_info)
    def cache(self,cache_queue, infer_queue):
        timeLast = time.time()
        print("C.cache process:", os.getpid())
        caches = []
        while True:
            data = cache_queue.get()
            caches.append(data)
            if len(caches) > 128 or time.time() - timeLast > 1:
                timeLast = time.time()
                infer_queue.put(caches)
                caches = []
    def predict(self,infer_queue, result_queue):
        print("C.predict process:", os.getpid())
        # 模型必须在这里初始化
        model = Model()
        while True:
            data = infer_queue.get()
            result = model(data)
            result = [ 'modelpredict_' + ele for ele in result]
            time.sleep(random.uniform(0.1,0.5))
            result_queue.put(result)

代码比较好理解,需要注意的是子进程在使用变量的时候,例如初始后的模型,应该要每一个子进程独立的进行初始化,不然会报错,就是C类中模型初始化不能在init中初始后,然后传入到每个子进程中去——而应该在每个子进程中初始化。

加载全部内容

相关教程
猜你喜欢
用户评论