多任务-进程

1 进程以及状态

1.1 进程

程序：例如xxx.py这是程序，是一个静态的

进程：一个程序运行起来后，代码+用到的资源 称之为进程，它是操作系统分配资源的基本单元。

不仅可以通过线程完成多任务，进程也是可以的

1.2 进程的状态

工作中，任务数往往大于cpu的核数，即一定有一些任务正在执行，而另外一些任务在等待cpu进行执行，因此导致了任务有不同的状态。

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

2 进程的创建-multiprocessing

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

2.1 两个while循环一起执行

import multiprocessing
import time


def run_proc():
    """子进程要执行的代码"""
    while True:
        print("----2----")
        time.sleep(1)


if __name__=='__main__':
    p = multiprocessing.Process(target=run_proc)
    p.start()
    while True:
        print("----1----")
        time.sleep(1)

说明：

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动

2.2 进程pid

import multiprocessing
import os
import time


def test():
    while True:
        # os.getpid获取当前进程的进程号   os.getppid获取当前进程的父进程号
        print("----in 子进程 pid=%d ,父进程的pid=%d---" % (os.getpid(), os.getppid()))
        time.sleep(0.5)


def main():
    # os.getpid获取当前进程的进程号   os.getppid获取当前进程的父进程号
    print("----in 主进程 pid=%d---父进程pid=%d----" % (os.getpid(), os.getppid()))
    p = multiprocessing.Process(target=test)
    p.start()


if __name__ == "__main__":
    main()

2.3 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（进程号）

2.4 给子进程指定的函数传递参数

import multiprocessing
import os
from time import sleep


def run_proc(name, age, **kwargs):
    for i in range(10):
        print('子进程运行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
        print(kwargs)
        sleep(0.2)


if __name__ == '__main__':
    p = multiprocessing.Process(target=run_proc, args=('test', 18), kwargs={"m": 20})
    print("我是进程：", p.name)
    p.start()
    sleep(1)  # 1秒中之后，立即结束子进程
    p.terminate()
    p.join()

运行结果:

我是进程： Process-1
子进程运行中，name= test,age=18 ,pid=1632...
{'m': 20}
子进程运行中，name= test,age=18 ,pid=1632...
{'m': 20}
子进程运行中，name= test,age=18 ,pid=1632...
{'m': 20}
子进程运行中，name= test,age=18 ,pid=1632...
{'m': 20}
子进程运行中，name= test,age=18 ,pid=1632...
{'m': 20}

2.5 进程间不共享全局变量

import multiprocessing
import os
import time

nums = [11, 22, 33]


def test1():
    nums.append(44)
    print("在进程中1中nums=%s" % str(nums))
    time.sleep(3)


def test2():
    print("在进程中2中nums=%s" % str(nums))


def main():
    print("----in 主进程 pid=%d---父进程pid=%d----" % (os.getpid(), os.getppid()))
    p = multiprocessing.Process(target=test1)
    p.start()

    # time.sleep(1)
    p.join()

    p2 = multiprocessing.Process(target=test2)
    p2.start()


if __name__ == "__main__":
    main()

运行结果:

----in 主进程 pid=6412---父进程pid=6180----
在进程中1中nums=[11, 22, 33, 44]
在进程中2中nums=[11, 22, 33]

3 进程、线程对比

3.1 功能对比

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

3.2 定义的不同

• 进程是系统进行资源分配和调度的一个独立单位.

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

3.3 区别

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

 3.4 优缺点

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

4 进程间通信-Queue

Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。

4.1 Queue的使用

可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序，首先用一个小实例来演示一下Queue的工作原理：

import multiprocessing

q = multiprocessing.Queue(3)  # 初始化一个Queue对象，最多可接收三条put消息
q.put("消息1")
q.put("消息2")
print(q.full())  # False
q.put("消息3")
print(q.full())  # True

# 因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常
try:
    q.put("消息4", True, 2)
except:
    print("消息列队已满，现有消息数量:%s" % q.qsize())

try:
    q.put_nowait("消息4")
except:
    print("消息列队已满，现有消息数量:%s" % q.qsize())

# 推荐的方式，先判断消息列队是否已满，再写入
if not q.full():
    q.put_nowait("消息4")

# 读取消息时，先判断消息列队是否为空，再读取
if not q.empty():
    for i in range(q.qsize()):
        print(q.get_nowait())

运行结果:

False
True
消息列队已满，现有消息数量:3
消息列队已满，现有消息数量:3
消息1
消息2
消息3

说明：

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

• 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)；

4.2 Queue实例

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

import multiprocessing
import time
import random


# 写数据进程执行的代码:
def write(q):
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())


# 读数据进程执行的代码:
def read(q):
    while True:
        if not q.empty():
            value = q.get(True)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break


if __name__ == "__main__":
    # 父进程创建Queue，并传给各个子进程：
    q = multiprocessing.Queue()
    pw = multiprocessing.Process(target=write, args=(q,))
    pr = multiprocessing.Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 等待pw结束:
    pw.join()
    # 启动子进程pr，读取:
    pr.start()
    pr.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    print('')
    print('所有数据都写入并且读完')

运行结果：

Put A to queue...
Put B to queue...
Put C to queue...
Get A from queue.
Get B from queue.
Get C from queue.

所有数据都写入并且读完

 例二：模拟从网上下载数据

import multiprocessing
import time

"""
一个进程向Queue中写入数据，另外一个进程从Queue中获取数据，
通过Queue完成了 多个需要配合的进程间的数据共享，从而能够 起到 解耦的作用
"""


def download_from_web(q):
    """下载数据"""
    # 模拟从网上下载的数据
    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()
    time.sleep(1)
    p2.start()


if __name__ == "__main__":
    main()

运行结果：

---下载器已经下载完了数据并且存入到队列中----
[11, 22, 33, 44]

5 进程的创建-进程池Pool

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

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

import multiprocessing
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))


if __name__ == '__main__':
    po = multiprocessing.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-----")

运行结果：

----start----
0开始执行,进程号为10188
1开始执行,进程号为8452
2开始执行,进程号为8352
1 执行完毕，耗时0.67
3开始执行,进程号为8452
0 执行完毕，耗时1.00
4开始执行,进程号为10188
2 执行完毕，耗时1.16
5开始执行,进程号为8352
4 执行完毕，耗时0.36
6开始执行,进程号为10188
6 执行完毕，耗时0.40
7开始执行,进程号为10188
5 执行完毕，耗时0.60
8开始执行,进程号为8352
3 执行完毕，耗时1.16
9开始执行,进程号为8452
9 执行完毕，耗时0.27
7 执行完毕，耗时0.72
8 执行完毕，耗时1.63
-----end-----

multiprocessing.Pool常用函数解析：

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

6 进程池中的Queue

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

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

下面的实例演示了进程池中的进程如何通信：

import multiprocessing
import time
import os
import random


def worker(i):
    start_time = time.time()
    print("%s开始执行，进程号为：%d" % (i, os.getpid()))
    time.sleep(random.random() * 2)
    end_time = time.time()
    print(i, "执行结束，共耗时%.2f" % (end_time - start_time))


def main():
    # 创建一个进程池
    po = multiprocessing.Pool(3)
    for i in range(10):
        po.apply_async(worker, (i,))

    print("--------start---------")
    po.close()
    po.join()
    print("---------end----------")


if __name__ == "__main__":
    main()

运行结果:

--------start---------
0开始执行，进程号为：5220
1开始执行，进程号为：10204
2开始执行，进程号为：6748
0 执行结束，共耗时0.72
3开始执行，进程号为：5220
2 执行结束，共耗时0.85
4开始执行，进程号为：6748
4 执行结束，共耗时1.03
5开始执行，进程号为：6748
1 执行结束，共耗时1.97
6开始执行，进程号为：10204
3 执行结束，共耗时1.46
7开始执行，进程号为：5220
7 执行结束，共耗时0.04
8开始执行，进程号为：5220
6 执行结束，共耗时0.37
9开始执行，进程号为：10204
5 执行结束，共耗时0.62
8 执行结束，共耗时0.42
9 执行结束，共耗时0.51
---------end----------

7 案例：文件夹copy器（多进程版）

初始代码如下： 

import os
import multiprocessing


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


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. 向进程池中添加 copy文件的任务
    for file_name in file_names:
        po.apply_async(copy_file, args=(file_name, old_folder_name, new_folder_name))

    po.close()
    po.join()


if __name__ == "__main__":
    main()

对上部代码进行优化：显示复制百分比

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("\r拷贝的进度为：%.2f %%" % (copy_ok_num * 100 / all_file_num), end="")
        if copy_ok_num >= all_file_num:
            break

    print()


if __name__ == "__main__":
    main()