python 多进程运行

1. 多进程

1、看到Pool有一个processes参数，这个参数可以不设置，如果不设置函数会跟根据计算机的实际情况来决定要运行多少个进程，我们也可自己设置，但是要考虑自己计算机的性能。

2、map()函数。需要传递两个参数，第一个参数就是需要引用的函数，第二个参数是一个可迭代对象，它会把需要迭代的元素一个个的传入第一个参数我们的函数中。因为我们的map会自动将数据作为参数传进去

3、pool()开启了，不要忘记pool.close() 和 pool.join() 关闭进程池，以及让主进程阻塞等待子进程的退出。

1.1

import time
from multiprocessing.pool import Pool
 
def numsCheng(i):
    return i * 2
 
if __name__ == '__main__':
    time1 = time.time()
    nums_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    pool = Pool(processes=5)
    result = pool.map(numsCheng, nums_list)
    pool.close()        # 关闭进程池，不再接受新的进程
    pool.join()         # 主进程阻塞等待子进程的退出
 
    print(result)
    time2 = time.time()
    print("计算用时：", time2-time1)

[2, 4, 6, 8, 10, 12, 14, 16, 18]
计算用时： 0.21639275550842285

1.2

1.3

2. 　多参数的情况

注意如果　想要多进程运行的这个函数 def fun_a，　需要同时传递两种类型的参数。

那么需要构建另外一个辅助函数，　　def fun_ass，　　在该辅助函数中调用想要运行的函数 fun_a, 通过这种调用的方式，　将多个参数传入到函数fun_a 中去；

2.1 通过辅助函数传递多个参数

import time
import multiprocessing
 
 
def job(x ,y):
	"""
	:param x:
	:param y:
	:return:
	"""
	return x * y
 
def job1(z):
	"""
	:param z:
	:return:
	"""
	return job(z[0], z[1])
 
 
if __name__ == "__main__":
	time1=time.time()
	pool = multiprocessing.Pool(2)
	data_list=[(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10)]
	res = pool.map(job1,data_list)
	time2=time.time()
	print(res)
	pool.close()
	pool.join()
	print('总共耗时：' + str(time2 - time1) + 's')

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
总共耗时：0.24999451637268066s

2.2　　实例代码

def multi_process_one2three_audio_store(data_dir, file, save_dir):

    """
    data_dir 待读取音频的文件目录，
    file　是读取当前音频文件的文件名，但是没有.wav 后缀;　

    save_dir: 在该文件下，　已经创建多个文件夹，
    每个文件夹的名字是以音频文件名称起的；
    每个文件夹用于　保存该cycle 分解出来的三个音频信号；

    """

    # 1. 读取该音频文件, 44k, sig.dtype = int32; 4k, sig.dtype = int16
    fs, sig = wav.read(data_dir + '/' + file + '.wav')

    # note , 这里在分解信号之前，　已经将每个数据进行了归一化处理；
    # 将数据范围归一化到0-1　之间, 数据归一化之后, sig.dtype = float64;
    sig = Normalization(sig)
    # 对采样率大于4k　的信号，通过50－２k的　带通滤波器
    if fs > 4000:
        sig = butter_bandpass_filter(sig, 50, 2000, fs, order=3)
    # 补齐到2的整数倍;
    if sig.size % 2 != 0:
        sig = np.append(sig, [0])

    # . 分解该音频文件；
    dq = DualQDecomposition(**dq_params)
    sig_high, sig_slow = dq(sig)
    sig_res = sig - sig_high - sig_slow

    # wav.write( 文件名，　采样率，　音频数据;)
    # cD: cofficient of Details, cA:cofficient of Approximation
    wav.write('./' + file + '_cD' + '.wav', fs, sig_high)
    wav.write('./' + file + '_cA' + '.wav', fs, sig_slow)
    wav.write('./' + file + '_res' + '.wav', fs, sig_res)

    # 5. 存储三个分解出来的音频文件到新建的文件夹下面；
    # shutil.move(dir + 'ICBHI_final_database/' + name[i] + '.wav', dir + 'testset/' + name[i] + '.wav')
    shutil.move('./' + file + '_cD' + '.wav', save_dir + '/' + str(file) + '/')
    shutil.move('./' + file + '_cA' + '.wav', save_dir + '/' + str(file) + '/')
    shutil.move('./' + file + '_res' + '.wav', save_dir + '/' + str(file) + '/')

    return 0


def ass_job(cur_para):
    """
    cur_para 列表传入的当前值；
    """

    return  multi_process_one2three_audio_store(cur_para[0], cur_para[1], cur_para[2])

def mkdir_decompose_audio(audio_dir, save_dir):
    """
    audio_dir: 待读取音频的文件夹，　训练集所在的文件夹/ 测试集所在的文件夹
    train_cycle_with_class,  test_cycle_with_class;

    save_dir:  在该文件夹下创建多个音频文件名的文件夹，新创建的每个文件夹用来保存分解出来的三个音频
    train_tqwt,  test_tqwt;
    """

    file_list = []
    for file  in  os.listdir(audio_dir):
        # 1. 读取文件名
        audio_name = file[:-4]
        # 2. 创建文件夹；
        makedirs(save_dir + '/' + str(audio_name) + '/')
        # 3. 将文件名和保存的路径添加到列表中；
        file_list.append((audio_dir, audio_name, save_dir))

    t1 = datetime.now()
    # 单个进程，函数调用，用于调试验证；
    # one2three_audio_store(file_list[0][0], file_list[0][1], file_list[0][2])

    # 使用多进程同时运行多个函数，　
    # file_list　列表中的每一项 file_list[i]都包含了三个参数，
    # 所以 file_list[i] 每次都会将三个参数传入到 one2three_audio_store()函数中去;
    # pool = mp.Pool(processes=args.ncpu)
    pool = mp.Pool(processes= 10)   # 启动10　个进程；
    # def multi_process_one2three_audio_store(data_dir, file, save_dir):
    # pool.map(multi_process_one2three_audio_store, file_list)

    pool.map(ass_job, file_list)
    pool.close()
    pool.join()


    t2 = datetime.now()
    duration = t2 - t1
    print(f" decompose  on the {
      
      audio_dir} done, and cost {
      
      duration} time  ")
    # decompose the audio  cycle done, and cost 11:41:16.873517 time





def makedirs(dirname):
    if not os.path.exists(dirname):
        os.makedirs(dirname)

2.3

3.

3.1

3.2

3.3

参考:
https://blog.csdn.net/xun527/article/details/123359502