进程

进程和进程状态

进程

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

进程的状态

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

WX20200419-174939.png

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

多进程

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

2个while循环一起执行

#-*- coding:utf-8 -*-
import time
from multiprocessing import Process

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

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

说明

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

进程pid

#-*- coding:utf-8 -*-
import os
import time
from multiprocessing import Process

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

if __name__ == "__main__":
    p = Process(target=run_proc, args=("test", 10), kwargs={"m":20})
    p.start()
    time.sleep(1)
    p.terminate()
    p.join()

Process语法

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

• target：如果传递了函数的引用，可以认为子进程就要执行这里的代码。
• args：给target指定函数传递的参数，以元组的方式传递。
• kwargs：给target指定函数传递关键字参数。
• group：指定进程组，大多数情况用不到。
  Process实例对象的常用方法：
• start()：启动子进程实例。
• is_alive()：判断子进程是否还活着。
• join(timeout)：是否等待子进程执行结束，或等待多少秒。
• terminate()：不管任务是否执行完，立即终止子进程。
  Process实例对象的常用属性：
• name：当前进程的别名，默认是Process-N，N是从1开始递增的整数。
• pid：当前进程的pid
  ####### 给子进程指定的函数传递参数

#-*- coding:utf-8 -*-
import os
import time
for multiprocessing import Process

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

if __name__ == "__main__":
    p = Process(target=run_proc, args=("test", 10), kwaargs={"m":20})
    p.start()
    time.sleep(1)
    p.terminate()
    p.join()

进程间通信 Queue

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

Queue的使用

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

#coding=utf-8
from Queue import Queue
from multiprocessing import Process

q = Queue(3) # 初始化一个Queue对象，最多可以接收3条消息
q.put("1")
q.put("2")
print(q.full()) # 判断Queue是否满了 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())

进程池Pool

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态生成多个进程。但如果是成千上百个目标，手动的创建进程的工作量巨大，此时就可以用到multiprocessing模块提供Pool方法。
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程来执行该请求，但是如果进程池中的进程数已经达到最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务。

# -*- coding:utf-8 -*-
import os, time, random
from multiprocessing import Process

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)
for i in range(0, 10):
    # Pool().apply_async(要调度的目标，(传递给目标的参数元组，))
    # 每次循环将会用空闲出来的子进程去调度目标
    po.apply_async(worker, (i, ))

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