多任务-进程

进程

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

进程的状态

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

代码

import time
import multiprocessing


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


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


def main():
    # t1 = threading.Thread(target=test1)
    # t2 = threading.Thread(target=test2)
    # t1.start()
    # t2.start()

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


if __name__ == "__main__":
    main()

• 进程pid

import os
import multiprocessing


def test():
    print("子进程的pid = %d : 父进程的pid = %d" % (os.getpid(),os.getppid()))


def main():
    # os.getpid获取当前进程的进程号
    # os.getppid获取父进程的进程号
    # 如果已经是父进程，得到系统进程id，如bash环境运行得到bash的id
    print("主进程的pid = %d : 系统进程的pid = %d" % (os.getpid(),os.getppid()))
    p = multiprocessing.Process(target=test)
    p.start()


if __name__ == "__main__":
    main()

• process传递参数

import multiprocessing
import os


def test(a, b, c, *args, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)


def main():
    print("子进程的pid = %d : 父进程的pid = %d" % (os.getpid(),os.getppid()))
    p = multiprocessing.Process(target=test,
                                args=[11, 22, 33, 44, 55, 66, 77, 88],
                                kwargs={"name": "小明", "age": 11})
    p.start()


if __name__ == "__main__":
    main()

• 多进程之间不共享全局变量

import multiprocessing
import time
import os

num = [11, 22, 33]


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


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


def main():
    print("主进程的pid = %d : 系统进程的pid = %d" % (os.getpid(), os.getppid()))
    p1 = multiprocessing.Process(target=test1)
    p2 = multiprocessing.Process(target=test2)

    p1.start()

    # join([timeout])：是否等待子进程执行结束，或等待多少秒
    p1.join()

    p2.start()


if __name__ == "__main__":
    main()

• 进程间的通信：队列Queue，先进先出
  • 创建队列 q = multiprocessing.Queue()
  • 写入 q.put()
  • 读取 q.get()
  • 是否为空 q.empty()
  • 是否为满 q.full()

import multiprocessing


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()
    p2.start()


if __name__ == "__main__":
    main()

• 进程池
  • 当创建的进程数量太多时，手动创建工作量大，此时可用进程池
  • 定义一个进程池，最大进程为3，po = Pool(3)
  • po().apply_async(要调用的目标,(传递给目标的参数元祖,))
  • po.apply_async(___, (___))
  • 关闭后，po不再接收新的请求，po.close()
  • 等待po中所有子进程执行完成，po.join()

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


def main():
    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-----")


if __name__ == "__main__":
    main()