线程丶进程丶协程（二）进程(2)

进程池Pool

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务，请看下面的实例：

import multiprocessing
import time


def copy_work():
    print("拷贝中....",multiprocessing.current_process().pid)
    time.sleep(0.3)


if __name__ == '__main__':

    # 创建进程池
    # Pool(3) 表示创建容量为3个进程的进程池
    pool = multiprocessing.Pool(3)

    for i in range(10):
        # 利用进程池同步拷贝文件，进程池中的进程会必须等上一个进程退出才能执行下一个进程
        # pool.apply(copy_work)
        pool.apply_async(copy_work)

    pool.close()
    # 注意：如果使用异步方式执行copy_work任务，主线程不再等待子线程执行完毕再退出！
    pool.join()

apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；

close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出，必须在close或terminate之后使用；
进程池中的Queue

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：

RuntimeError: Queue objects should only be shared between processes through inheritance.

import multiprocessing
import time

# 写入数据的方法
def write_data(queue):
    # for循环 向消息队列中写入值
    for i in range(5):
        # 添加消息
        queue.put(i)
        time.sleep(0.2)


# 创建读取数据的方法
def read_data(queue):
    # 循环读取数据
    while True:
        # 判断队列是否为空
        if queue.qsize() == 0:
            print("队列为空～")
            break

        # 从队列中读取数据
        result = queue.get()
        print(result)


if __name__ == '__main__':

    # 创建进程池
    pool = multiprocessing.Pool(2)

    # 创建进程池队列
    queue = multiprocessing.Manager().Queue()

    # 在进程池中的进程间进行通信
    # 使用线程池同步的方式，先写后读
    # pool.apply(write_data, (queue, ))
    # pool.apply(read_data, (queue, ))

    # apply_async() 返回ApplyResult 对象
    result = pool.apply_async(write_data, (queue, ))
    # ApplyResult对象的wait() 方法，表示后续进程必须等待当前进程执行完再继续
    result.wait()
    pool.apply_async(read_data, (queue, ))

    pool.close()
    # 异步后，主线程不再等待子进程执行结束，再结束
    # join() 后，表示主线程会等待子进程执行结束后，再结束
    pool.join()

下面就利用进程的只是完成一个文件复制的多进程程序.()

import multiprocessing
import os


# file_name 文件名
# source_dir 源文件目录
# dest_dir 目标文件目录
def copy_work(file_name, source_dir, dest_dir):

    # 拼接路径
    source_path = source_dir+"/"+file_name

    dest_path = dest_dir+"/"+file_name

    print(source_path, "----->", dest_path)
    # 打开源文件、创建目标文件
    with open(source_path,"rb") as source_file:
        with open(dest_path,"wb") as dest_file:
            while True:
                # 循环读取数据
                file_data = source_file.read(1024)
                if file_data:
                    # 循环写入到目标文件
                    dest_file.write(file_data)
                else:
                    break


if __name__ == '__main__':

    # 1、定义源文件目录和目标文件夹的目录
    source_dir = "./ test"
    dest_dir = "/home/python/Desktop/test"

    try:
        # 2、创建目标文件夹目录
        os.mkdir(dest_dir)

    except:
        print("目标文件夹已经存在，未创建~")

    # 3、列表得到所有的源文件中的文件
    file_list = os.listdir(source_dir)
    print(file_list)

    # 4、创建进程池
    pool = multiprocessing.Pool(3)
    # 5、for 循环，依次拷贝每个文件
    for file_name in file_list:
        # copy_work(file_name, source_dir, dest_dir)
        pool.apply_async(copy_work, args=(file_name, source_dir, dest_dir))
    # 6、关闭进程池
    pool.close()
    # 7、设置主进程等待子进程执行结束再退出
    pool.join()

线程丶进程丶协程（二）进程(2)

进程池Pool

进程池中的Queue

猜你喜欢