python 进程实现多任务

1.导入进程模块

import multiprocessing

1.2 Process进程类的语法结构如下：

Process([group [, target [, name [, args [, kwargs]]]]])

group：指定进程组，目前只能使用None
target：执行的目标任务名
name：进程名字
args：以元组方式给执行任务传参
kwargs：以字典方式给执行任务传参

Process创建的实例对象的常用方法：

start()：启动子进程实例（创建子进程）
join([timeout])：是否等待子进程执行结束，或等待多少秒
terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性：

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数
pid：当前进程的pid（进程号）multiprocessing.current_process().pid 或os.getpid()
获取父进程编号：os.getppid()

2.进程注意点

进程之间不共享全局变量（创建子进程其实是对主进程进行拷贝，进程进程之间相互独立，访问的全局变量不是同一个）需要使用Queue
主进程默认会等待所有的子进程执行完成后程序才会退出
可以为设置守护主进程，但是只能通过sub_process.daemon = True
可以直接销毁子进程，主进程退出之前把子进程销毁，sub_process.terminate()

3.进程间通信

queue添加数据：

queue = multiprocessing.Queue(maxsize=-1) # -1表示添加任意多个数据

queue.put(数据) # queue可以放入任何类型的数据，如果队列满了，数据会进行等待，直到消息队列有空闲位置才放入数据

queue.put_nowait(数据）# 队列如果满了，此方法会报错

queue判断队列是否满了

result = queue.full() # 若满了返回True

result = queue.empty() # 坑点，此方法判断消息队列不靠谱，不推荐使用

queue.qusize() # 查看当前队列里消息的个数

queue获取数据

value = queue.get() # 队列中的元素是FIFO（先进先出）

value = queue.get_nowait() # 若队列为空立即报错，不推荐使用

利用消息队列完成进程通信

import multiprocessing
import time


# 添加数据到指定队列
def add_data(current_queue):
    # 循环往指定队列里面添加数据
    for value in ["苹果", "香蕉", "西瓜", "榴莲", "山竹"]:
        # 判断队列是否满了
        if current_queue.full():
            print("队列满了")
            break

        current_queue.put(value)
        print("add_data:", value)
        time.sleep(0.2)


# 读取数据从指定队列
def read_data(current_queue):
    while True:
        #if current_queue.empty():
        if current_queue.qsize() == 0:
            print("队列空了")
            break

        value = current_queue.get()
        print("read_data:", value)


if __name__ == '__main__':

    # 创建消息队列
    queue = multiprocessing.Queue(3)

    # 添加数据的进程
    add_data_process = multiprocessing.Process(target=add_data, args=(queue,))
    read_data_process = multiprocessing.Process(target=read_data, args=(queue,))

    # 启动进程执行对应的程序
    add_data_process.start()
    # 主进程等待添加数据的子进程执行完成以后再启动读取数据的进程
    add_data_process.join()
    read_data_process.start()

进程池

用来自动创建大量线程，process_pool = multiprocessing.Pool(max_size)

初始化进程池时，可以指定一个最大进程数，当有新的请求提交到Pool时，如果池内有空闲进程则使用该进程，若无空闲进程，且进程池还未达到最大值，那么久会创建一个新的进程来执行该请求，若达到最大值，那么该进程就会等待，直到池中有进程结束，才会使用之前的进程来执行新的任务。

进程池分为同步执行任务和异步执行任务。

同步执行任务：process_pool.apply(work)，默认创建的子进程为守护主进程的，但主进程会被阻塞到子进程执行结束

异步执行任务：process_pool.apply_async(work),创建的子进程是守护主进程的，但它是非阻塞的。

主进程需要等待进程池把所有任务完成才能退出

pool.close() # 关闭进程池，明确告诉主进程不再接受其它任务

pool.join() # 等待进程池完成所有任务

demo 进程池完成多任务版文件夹拷贝

import os
import shutil  # 文件操作的高级模块
import multiprocessing
import time


# 拷贝文件的操作
def copy_work(src_dir_path, dst_dir_path, file_name):
    src_file_path = src_dir_path + "/" + file_name  # test/1.txt
    dst_file_path = dst_dir_path + "/" + file_name
    print(multiprocessing.current_process().pid)
    # 打开目标文件
    with open(dst_file_path, "wb") as dst_file:
        # 打开源文件，把源文件的数据写入到目标文件
        with open(src_file_path, "rb") as src_file:
            # 循环读取文件中的数据
            while True:
                # 读取一次源文件中的数据
                src_file_data = src_file.read(1024)
                if src_file_data:
                    # 把源文件的数据写入到目标文件里面
                    dst_file.write(src_file_data)
                else:
                    break
    time.sleep(0.5)


if __name__ == '__main__':
    # 源目录的路径
    src_dir_path = "test"
    # 目标目录的路径
    dst_dir_path = "/home/python/Desktop/test"
    # 判断目标目录是否在桌面存在
    if os.path.exists(dst_dir_path):
        # 代码执行到此，说明桌面上有指定的目标目录，递归删除非空目录
        shutil.rmtree(dst_dir_path)  
    os.mkdir(dst_dir_path)
    file_name_list = os.listdir(src_dir_path)
    # 创建进程池
    pool = multiprocessing.Pool(3)
    for file_name in file_name_list:
        # print(file_name)
        # 使用进程池以异步的方式完成多任务文件的拷贝
        pool.apply_async(copy_work, args=(src_dir_path, dst_dir_path, file_name))

    # 关闭进程池
    pool.close()
    pool.join()

进程池在执行任务的时候会尽量少创建进程，合理利用现有进程完成多任务，这样可以减少资源开销。

python 进程实现多任务

猜你喜欢