Python 多任务 - 02 进程

目录
一、进程概念
二、使用Process完成多线程
三、进程、线程的区别
四、通过队列完成进程间通信
五、进程池概念以及创建
六、案例——多任务文件夹copy

一、进程概念

一个程序运行起来后，代码+用到的资源称之为进程，它是操作系统分配资源的基本单元。不仅可以通过线程完成多任务，进程也是可以的

进程的状态

进程的状态.png

就绪态：运行的条件都已经慢去，正在等在cpu执行
执行态：cpu正在执行其功能
等待态：等待某些条件满足，例如一个程序sleep了，此时就处于等待态

二、使用Process完成多线程

multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情

import multiprocessing
import time


def test1():
    while True:
        print("------1-----")
        time.sleep(1)


def test2():
    while True:
        print("------2-----")
        time.sleep(1)


def main():
    p1 = multiprocessing.Process(target=test1)
    p2 = multiprocessing.Process(target=test2)
    p1.start()
    p2.start()


if __name__ == '__main__':
    main()

三、进程、线程的区别

定义

进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源

功能

进程：能够完成多任务，比如在一台电脑上能够同时运行多个QQ
线程：能够完成多任务，比如一个QQ中的多个聊天窗口

区别

一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
线程不能够独立执行，必须依存在进程中

优缺点

线程执行开销小，但不利于资源的管理和保护；而进程正相反。

四、通过队列完成进程间通信

可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序
Queue的基础使用

from multiprocessing import Queue


# 初始化Queue()对象时若括号中没有指定最大可接收的消息数量，或数量为负值
# 那么就代表可接受的消息数量没有上限（直到内存的尽头）
q = Queue(3)  # 初始化一个Queue对象，最多可接收三条put消息


q.put("1111")

q.put(2222)

# 如果队列满了，返回True,反之False
print(q.full())  # False


q.put("3333")

print(q.full())  # True

# 如果队列为空，返回True，反之False
print(q.empty())  # False

print(q.get())  # 1111

print(q.get())  # 2222

print(q.get())  # 3333

Queue实例
在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

import multiprocessing


def download_from_web(q):
    """下载数据"""
    # 模拟从网上下载数据
    data = [11, 22, 33]
    # 向队列中写入数据
    for i in data:
        q.put(i)
    print("下载器已经下载完了数据并且存入队列中")


def analysis_data(q):
    """数据处理"""
    # 从队列中获取数据
    waitting_analysis_data = list()
    while True:
        data = q.get()
        waitting_analysis_data.append(data)
        if q.empty():
            break

    # 模拟数据处理
    print(waitting_analysis_data)


def main():
    q = multiprocessing.Queue()

    p1 = multiprocessing.Process(target=download_from_web,args=(q,))
    p2 = multiprocessing.Process(target=analysis_data, args=(q,))
    p1.start()
    p2.start()


if __name__ == '__main__':
    main()

图片.png

五、进程池概念以及创建

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

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

from multiprocessing import Pool
import os, time, random


def test1(msg):
    t_start = time.time()
    # random.random()随机生成0~1之间的浮点数
    time.sleep(random.random() * 2)
    t_stop = time.time()
    print(msg, "执行完毕，耗时%0.2f" % (t_stop - t_start))


po = Pool(3)   # 定义一个进程池，最大进程数3
for i in range(0, 5):
    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
    # 每次循环将会用空闲出来的子进程去调用目标
    po.apply_async(test1, (i,))


print("------start------")
po.close()  # 关闭进程池，关闭后po不再接收新的请求
po.join()   # 等待po中所有子进程执行完成，必须放在close语句之后
print("------end------")

multiprocessing.Pool常用函数解析：

apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；
close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出，必须在close或terminate之后使用

六、案例——多任务文件夹copy

import multiprocessing, os, time, random


def copy_file(queue,file_name,old_folder_name,new_folder_name):
    """完成文件的复制"""
    
    # 复制原文件夹的文件到新的文件夹中去
    # print("从%s->%s 文件名是:%s" % (old_folder_name,new_folder_name,file_name))
    old_file = open(old_folder_name + "/" + file_name,"rb")
    content = old_file.read()
    old_file.close()
    new_file = open(new_folder_name + "/" + file_name,"wb")
    new_file.write(content)
    new_file.close()

    # 如果拷贝完了文件，那么久向队列中写入一个消息，表示已经完成
    queue.put(file_name)

def main():
    pass
    # 1.获取用户要拷贝的文件夹的文字
    old_folder_name = input("请输入要复制的文件夹名字:")

    try:
        # 2.创建一个新的文件夹
        new_folder_name = old_folder_name + "[复件]"
        os.mkdir(new_folder_name)
    except:
        pass

    # 3.获取文件夹中所有带有copy的文件名字 listdir()
    file_names = os.listdir(old_folder_name)
    print(file_names)
    # 4.创建进程池
    po = multiprocessing.Pool(5)

    # 5. 创建一个队列 (用来显示进度)
    queue = multiprocessing.Manager().Queue()

    # 6.向进程池中添加copy文件的任务
    for file_name in file_names:
        # 向进程池中添加任务
        po.apply_async(copy_file, args=(queue,file_name,old_folder_name,new_folder_name))
    po.close()
    # po.join()
    # 主进程显示进度
    all_file_count = len(file_names) # 所有文件的个数
    copy_num = 0
    while True:
        file_name = queue.get()
        copy_num += 1
        print("\r拷贝的进度：%.f%%" %(copy_num* 100/all_file_count),end="")

        if copy_num >= all_file_count:
            print()
            print("copy all done")
            break


if __name__ == '__main__':
    main()

多任务文件夹copy.gif