多任务---进程

最新推荐文章于 2019-10-11 13:51:07 发布

阿公带你飞。

最新推荐文章于 2019-10-11 13:51:07 发布

阅读量93

点赞数

本文链接：https://blog.csdn.net/weixin_44872216/article/details/95073838

版权

进程

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

线程与进程对比

功能

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

定义的不同

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

区别

一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
线线程不能够独立执行，必须依存在进程中
可以将进程理解为工厂中的一条流水线，而其中的线程就是这个流水线上的工人

区别

线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。

进程的建立

进程的创建-multiprocessing

与线程类似，只需要将模块 threading =====> multiprocessing
然后调用该模块中的 Process 创建实例，在用 start() 启动

import time
import multiprocessing


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()

Process语法结构

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

target如果传递了函数的引用，可以任务这个子进程就执行这里的代码
args 给target指定的函数传递的参数，以元组的方式传递
kwargs 给target指定的函数传递命名参数
name 给进程设定一个名字，可以不设定
group 指定进程组，大多数情况下用不到

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

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

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

name 当前进程的别名，默认为Process-N，N为从1开始递增的整数
pid 当前进程的pid（进程号）

进程间通信-Queue

首先，进程之间是不共享全局变量的，可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序

Queue的使用

import multiprocessing


def download_from_web():
    # 模拟从网上下载的数据
    data = [11, 22, 33, 44]

    # 向队列中写入数据
    for temp in data:
        q.put(temp)

    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():
    # 1 创建一个队列
    q = multiprocessing.Queue()

    # 2 创建多个进程，将队列的引用当做实参进行传递到里面
    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()

说明

q=Queue(n) 初始化 Queue()对象，n为接收消息的最大数量，不写的话就默认系统最大
Queue.qsize() 返回当前队列包含的消息数量；
Queue.empty() 如果队列为空，返回True，反之False ；
Queue.full() 如果队列满了，返回True,反之False；

Queue.get([block[, timeout]]) 获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

  1）如果block使用默认值，且没有设置timeout（单位秒）
  消息列队如果为空，此时程序将被阻塞（停在读取状态）
  直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒
  若还没读取到任何消息，则抛出"Queue.Empty"异常；

  2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；

Queue.get_nowait() 相当Queue.get(False)；

Queue.put(item,[block[, timeout]]) 将item消息写入队列，block默认值为True；

  1）如果block使用默认值，且没有设置timeout（单位秒）
  消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态）
  直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒
  若还没空间，则抛出"Queue.Full"异常；

  2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；

Queue.put_nowait(item) 相当Queue.put(item, False)；

进程池Pool

当需要创建任务目标有很多时，逐个创建对应的子进程就很不现实，工作量非常大，这时就可以用multiprocessing模块提供的Pool方法
创建一个 Pool ，指定一个最大进程数，若有新的请求传到 Pool 时，如果 Pool 没满，则就创建进程，若 Pool 已满，那么该请求就会等待 Pool 中某个进程结束，再创建

from multiprocessing import Pool
import os
import time
import random

def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d" % (msg,os.getpid()))
    # 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,10):
    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
    # 每次循环将会用空闲出来的子进程去调用目标
    po.apply_async(worker,(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之后使用；

进程池中的Queue

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()而不是multiprocessing.Queue() 否则会报错

文件夹copy器(多进程版)

import os
import multiprocessing


def copy_file(q, file_name, old_folder_name, new_folder_name):
    """完成文件的复制"""
    # print("======>模拟copy文件：从%s--->到%s 文件名是:%s" % (old_folder_name, new_folder_name, file_name))
    old_f = open(old_folder_name + "/" + file_name, "rb")
    content = old_f.read()
    old_f.close()

    new_f = open(new_folder_name + "/" + file_name, "wb")
    new_f.write(content)
    new_f.close()

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


def main():
    # 1. 获取用户要copy的文件夹的名字
    old_folder_name = input("请输入要copy的文件夹的名字：")

    # 2. 创建一个新的文件夹
    try:
        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. 创建一个队列
    q = multiprocessing.Manager().Queue()

    # 6. 向进程池中添加 copy文件的任务
    for file_name in file_names:
        po.apply_async(copy_file, args=(q, file_name, old_folder_name, new_folder_name))

    po.close()
    # po.join()
    all_file_num = len(file_names)  # 测一下所有的文件个数
    copy_ok_num = 0
    while True:
        file_name = q.get()
        # print("已经完成copy：%s" % file_name)
        
        copy_ok_num += 1

        print("\n拷贝的进度为：%.2f %%" % (copy_ok_num*100/all_file_num), end="")
        if copy_ok_num >= all_file_num:
            break
            
    print()


if __name__ == "__main__":
    main()