python多进程加速处理数据

1 批量更新数据库操作

1.1单参数，无返回情况

from pic_md5_result import get_md5_value
#将数据的处理分装成函数
def mul_procee(data):
    mysql2 = ConnectMySQL(Config)
    flag = 0
    for data_item in data:
        flag +=1
        id = data_item["id"]
        img = data_item['upload_image']
        img_decode = base64.b64decode(img)
        img_array = np.fromstring(img_decode, np.uint8)
        value = get_md5_value(img_array)
        mysql2.undate_md5(value, id)
        
if __name__ == '__main__':
    mysql = ConnectMySQL(Config)
    data = mysql.select_data()
    n = len(data) // 2000#根据数据总量分割每个进程处理的数据量
    data_list = []
    for i in range(n+1):
        da = data[i * 2000: (i + 1) * 2000]
        data_list.append(da)
    p = Pool(len(data_list))#根据切分的数量确定进程池数量
    p.map(mul_procee, data_list)
    p.close()
    p.join()

1.2多参数，有返回情况

from pic_md5_result import get_md5_value
#将数据的处理分装成函数
def mul_procee(data,datas):
    flag = 0
	for da in datas:
		if da >data:
			flag = 1
		else:
			continue
	return flag
	
def job(z):
	return is_diff(z[0], z[1])
	
if __name__ == '__main__':
    
    mysql = ConnectMySQL(Config)
    data = mysql.select_data()
    n = len(data) // 2000#根据数据总量分割每个进程处理的数据量
    data_list = []
    for i in range(n+1):
        da = data[i * 2000: (i + 1) * 2000]
        das = (1,da)
        data_list.append(das)
    p = Pool(len(data_list))#根据切分的数量确定进程池数量
    res = p.map(job, data_list)
    p.close()
    p.join()
    print(res)

2 multiprocessing中pool组件的使用(apply,apply_async,map,map_async)区别

2.1，apply方法是阻塞的方法。

假设现在设置了进程池为4个（Pool(4）)，也就是共有1,2,3,4四个子进程，阻塞的意思是，子进程1执行完毕后，子进程2才能继续进行。 
相当于是一个进程在跑，就是因为apply是阻塞的。必须一个子进程结束后，下一个子进程才能进行。所有几乎不使用apply方法。

2.2，apply_async 是异步非阻塞的方法。

假设现在设置了进程池为4个（Pool(4）)，也就是共有1,2,3,4四个子进程，非阻塞的意思是，子进程1执行的同时，子进程2、3、4也同步执行。

2.3，map和map_async

功能差不多，主要是后者有callback 和errorcallback ，便于处理返回结果，实行过程中，效率是一样的。

代码实验参考

# map
results = pool.map(worker, [1, 2, 3])

# apply
for x, y in [[1, 1], [2, 2]]:
    results.append(pool.apply(worker, (x, y)))

def collect_result(result):
    results.append(result)

# map_async
pool.map_async(worker, jobs, callback=collect_result)

# apply_async
for x, y in [[1, 1], [2, 2]]:
    pool.apply_async(worker, (x, y), callback=collect_result)

3 多进程带进度条方式处理数据

from multiprocessing import Pool,cpu_count
import os
from tqdm import tqdm


def worker(item):
    imgname, imgtext = item.split(" ")[0].strip(), item.split(" ")[1].strip()
    imglabel_name = imgname.split(".")[0] + ".txt"
    root_labels_path = r"Datasets\labels"
    imglabel_path = os.path.join(root_labels_path, imglabel_name)
    img_path = os.path.join(r"Datasets\images",imgname)
    if os.path.exists(img_path):
        with open(imglabel_path, "w") as file:
            file.write(imgtext)
    else:
        print(imgname)


if __name__ == '__main__':
    total_labels_path = r"Datasets\labels.txt"
    root_labels_path = r"Datasets\labels"
    os.makedirs(root_labels_path, exist_ok=True)
    with open(total_labels_path, "r", encoding='utf-8') as f:
        total_labels = f.readlines()
    print(f"创建的最大进程池数量：{cpu_count()}")
    # ------------- 配置好进度条 -------------
    pbar = tqdm(total=len(total_labels))
    pbar.set_description(' Flow ')
    update = lambda *args: pbar.update()
    p = Pool(cpu_count())
    for i in total_labels:
        p.apply_async(worker, args=(i,),callback=update)
    p.close()
    p.join()