Python学习（三）进程

进程

创建进程：

在Python中，由于它是跨平台的软件，所以multiprocessing模块就是跨平台版本的多进程模块，multiprocessing模块提供了一个Process类来代表一个进程对象

from multiprocessing import Process
import os
# 子进程要执行的代码
def run_proc(name):
print('子进程运行中， name= %s ,pid=%d...' % (name, os.getpid()))
if __name__=='__main__':
print('父进程 %d.' % os.getpid())
p = Process(target=run_proc, args=('test',))
print('子进程将要执行')
p.start()
p.join()
print('子进程已结束')

说明:
创建子进程时， 只需要传入一个执行函数和函数的参数， 创建一个Process实例， 用start()方法启动， 这样创建进程比fork()还要简单。
join()方法可以等待子进程结束后再继续往下运行， 通常用于进程间的同步。
Process语法结构如下：
Process([group [, target [, name [, args [, kwargs]]]]])
target： 表示这个进程实例所调用对象；
args： 表示调用对象的位置参数元组；
kwargs： 表示调用对象的关键字参数字典；
name： 为当前进程实例的别名；
group： 大多数情况下用不到；
Process类常用方法：
is_alive()： 判断进程实例是否还在执行；
join([timeout])： 是否等待进程实例执行结束， 或等待多少秒；
start()： 启动进程实例（创建子进程） ；
run()： 如果没有给定target参数， 对这个对象调用start()方法时， 就将执行对象中的run()方法；
terminate()： 不管任务是否完成， 立即终止；
Process类常用属性：
name： 当前进程实例别名， 默认为Process-N， N为从1开始递增的整数；
pid： 当前进程实例的PID值；

进程池：

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

import multiprocessing
import os
import time

def copy(index):
    print('当前进程的编号',os.getpid())
    print(index)
    time.sleep(1)


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)

    for i in range(10):
        pool.apply_async(copy,(i,))
    pool.close()
    pool.join()
    # join的作用：主进程阻塞，等待子进程

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

进程间通信：

Queue的使用：

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

import multiprocessing

# 写数据任务

def write(queue):
    for i in range(10):
        if queue.full():
            print('已经满员，不能再存')
            break
        queue.put(i)

# 读取任务\

def read(queue):
    while True:
        if queue.empty():
            print('没有值啦')
            break
        print(queue.get())

if __name__ == '__main__':

    queue = multiprocessing.Queue(5)


    t1 = multiprocessing.Process(target=write,args=(queue,))

    t2 = multiprocessing.Process(target=read,args=(queue,))

    t1.start()

    t1.join()
    t2.start()

说明
初始化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”异常；