【工程实践】python实现多进程

1 多线程与多进程

        Python中比较常见的并发方式主要有两种：多线程和多进程。

1-1 多线程

        多线程即在一个进程中启动多个线程执行任务。一般来说使用多线程可以达到并行的目的，但由于Python中使用了全局解释锁GIL的概念，导致Python中的多线程并不是并行执行，而是“交替执行”。类似于下图。

        所以Python中的多线程适合IO密集型任务，而不适合计算密集型任务。Python提供两组多线程接口，一是thread模块_thread，提供低等级接口。二是threading模块，提供更容易使用的基于对象的接口，可以继承Thread对象来实现线程，此外其还提供了其它线程相关的对象，例如Timer，Lock等。

1-2 多进程

         由于Python中GIL的原因，对于计算密集型任务，Python下比较好的并行方式是使用多进程，这样可以非常有效的使用CPU资源。当然同一时间执行的进程数量取决你电脑的CPU核心数。在支持多任务操作系统中，一个应用程序会被分解成多个独立运行的较小的程序。操作系统会将这些线程分配到多核处理器，以提升系统性能。执行过程如下图。每个进程都拥有自己的地址空间、内存、文件描述符和其他系统资源。多进程的好处在于可以使程序并行执行，从而提高程序的运行效率。

        如果每个子进程执行需要消耗的时间非常短（执行+1操作等），这不必使用多进程，因为进程的启动关闭也会耗费资源。当然使用多进程往往是用来处理CPU密集型（科学计算）的需求，如果是IO密集型（文件读取，爬虫等）则可以使用多线程去处理。

2 多进程实现

2-1 multiprocessing

2-1-1 Process

        multiprocessing模块提供了一个Process类，可以用来创建和管理进程。下面是一个简单的示例。

multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
参数介绍：
    1. group默认为None（目前未使用）
    2. target代表调用对象，即子进程执行的任务
    3. name为进程名称
    4. args调用对象的位置参数元组，args=(value1, value2, ...)
    5. kwargs调用对象的字典，kwargs={key1:value1, key2:value2, ...}

    6. daemon表示进程是否为守护进程，布尔值　　 　
方法介绍：

    1.Process.start() 启动进程，并调用子进程中的run()方法

    2. Process.run() 进程启动时运行的方法，在自定义时必须要实现该方法　　     

    3.Process.terminate() 强制终止进程，不进行清理操作，如果Process创建了子进程，会导致该进程变成僵尸进程　　

    4.Process.join() 阻塞进程使主进程等待该进程终止　　

    5.Process.kill() 与terminate()相同　　

    6.Process.is_alive() 判断进程是否还存活，如果存活，返回True　　

    7.Process.close() 关闭进程对象，并清理资源，如果进程仍在运行则返回错误　　

import multiprocessing

def worker(x,y,z):
    """该函数将在子进程中执行"""
    print(x,y,z)

if __name__ == '__main__':
    # 创建子进程
    p = multiprocessing.Process(target=worker,args = (1,2,3))
    # 启动子进程
    p.start()
    # 等待子进程结束
    p.join()

        在上面的代码中，worker函数将在子进程中执行。首先，创建了一个Process对象，指定target参数为worker函数。然后，通过调用start方法启动子进程，最后调用join方法等待子进程结束。

        示例：        

def get_final_result(chunk):
    #以任意一chunk为实例进行处理，其余的chunk均按照此逻辑运行
    for index in tqdm((range(len(chunk)))) :
        str_data = chunk[index]
        test_dict = ast.literal_eval(str_data)
        text = test_dict['text'].split('航空公司不会')[0].split('如需')[0].split('若需')[0].split('服务电话')[0].split('服务热线')[0].split('热线')[0].split('客服电话')[0].split('请拨打')[0].split('请打')[0].split('致电')[0].split('联系')[0].split('来电')[0]
        text = text.replace('（','').replace('）','').replace('(','').replace(')','')
        label = test_dict['label']
        result = get_result(text)
        write_file(result)
    
if __name__ == "__main__":
    #读入航班信息
    file_path = '/home/zhenhengdong/WORk/SMS_Parsing/规则/Data/原始_airports.json'
    with open(file_path, 'r', encoding='utf8') as f:
        json_filedata = f.readlines()
    #启动进程池
    pool = multiprocessing.Pool(20)
    #划分chunk
    chunks = [json_filedata[start:start + 1000] for start in range(0, len(json_filedata), 1000)]
    #将所有的chunk统一传进处理函数中
    results = pool.map(get_final_result,chunks)

2-1-2 Pool

        如果需要创建大量的进程，那么使用Process类可能会导致系统资源的浪费。此时，可以使用Pool类来创建进程池。下面是一个简单的示例。

import multiprocessing

def worker(num):
    """该函数将在子进程中执行"""
    print('Worker %d' % num)

if __name__ == '__main__':
    # 创建进程池
    pool = multiprocessing.Pool(4)
    # 启动进程池中的进程
    pool.map(worker, range(10))
    # 关闭进程池
    pool.close()
    # 等待进程池中的进程结束
    pool.join()

        在上面的代码中，Pool类的构造函数中指定了进程池的大小为4，然后通过调用map方法来启动进程池中的进程。map方法会将worker函数和range(10)序列中的每个元素一一对应，然后将它们作为参数传递给进程池中的进程。最后，调用close方法关闭进程池，并调用join方法等待所有进程结束。

2-2 partial

        针对一些特殊需求，需要对map函数传递两个或者多个参数，这时单纯的map函数已经不能满足需求了，就需要借助偏函数来完成。

        偏函数是python自带的包，直接导入就能用。偏函数partial的第一个参数就是所承载的原函数，之后原函数的参数再依次传入partial函数。

from functools import partial
#定义
def add_num(x, y):
    return x + y
# 承载add_num函数，并传入第一个参数
para = partial(add_num, 3)
# 传递第二个参数,就是把2传给para
result = para(2)
# 输出最后的结果
print(result)

2-3 Pool与partial处理数据​​​​​​​

import multiprocessing
import functools

def drop_app_index(drop_list, chunk):
    for element in tqdm(drop_list):
        chunk = chunk.drop(index = chunk[(chunk.pkg_name == element)].index.tolist())
    return chunk

pool = multiprocessing.Pool(20)
drop_list = list(data['pkg_name'].value_counts().keys())[600:]
print(len(drop_list))
# 将DataFrame拆分为多个片段
chunks = [data.iloc[start:start + 10000] for start in range(0, len(data), 10000)]
#偏函数
g_with_a = functools.partial(drop_app_index, drop_list)
results = pool.map(g_with_a,chunks)
#results = pool.map(partial(process_chunk,drop_list),chunks)
# 合并所有处理结果
df_result = pd.concat(results)
data = df_result.reset_index(drop=True)