多进程

1.调度算法

　　时间片轮转

　　优先级调度

2.并发和并行

　　并发：进程的数量对于CPU，CPU通过快速切换来处理多进程问题

　　并行：有足够的CPU来处理多进程问题

3.子进程的创建

　需要导入Process包中的multiprocessing模块　

#coding=utf-8
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('⼦进程已结束')

4.Process语法结构：

　　1.Process([group [, target [, name [, args [, kwargs]]]]])
　　　　target：表示这个进程实例所调⽤对象；
　　　　args：表示调⽤对象的位置参数元组；
　　　　kwargs：表示调⽤对象的关键字参数字典；
　　　　name：为当前进程实例的别名；
　　　　group：⼤多数情况下⽤不到；

　　2.Process类常⽤⽅法：
　　　　is_alive()：判断进程实例是否还在执⾏；
　　　　join([timeout])：是否等待进程实例执⾏结束，或等待多少秒；
　　　　start()：启动进程实例（创建⼦进程）；
　　　　run()：如果没有给定target参数，对这个对象调⽤start()⽅法时，就将执
　　　　　　　　⾏对象中的run()⽅法；
　　　　terminate()：不管任务是否完成，⽴即终⽌；
　　3.Process类常⽤属性：
　　　　name：当前进程实例别名，默认为Process-N，N为从1开始递增的整
　　　　　　　　数；
　　　　pid：当前进程实例的PID值；

from multiprocessing import Process
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.5)
if __name__=='__main__':
　　print('⽗进程 %d.' % os.getpid())
　　p = Process(target=run_proc, args=('test',18), kwargs={"m":20
　　print('⼦进程将要执⾏')
　　p.start()
　　sleep(1)
　　p.terminate()
　　p.join()
　　print('⼦进程已结束')

5.进程池Pool

　　　　初始化Pool时，可以指定⼀个最⼤进程数，当有新的请求提交到Pool中时，
　　如果池还没有满，那么就会创建⼀个新的进程⽤来执⾏该请求；但如果池中
　　的进程数已经达到指定的最⼤值，那么该请求就会等待，直到池中有进程结
　　束，才会创建新的进程来执⾏。

from multiprocessing import Pool
import os,time,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常⽤函数解析：
　　　　1.apply_async(func[, args[, kwds]]) ：使⽤⾮阻塞⽅式调⽤func（并⾏执
　　　　⾏，堵塞⽅式必须等待上⼀个进程退出才能执⾏下⼀个进程），args为
　　　　传递给func的参数列表，kwds为传递给func的关键字参数列表；
　　　　2.apply(func[, args[, kwds]])：使⽤阻塞⽅式调⽤func
　　　　3.close()：关闭Pool，使其不再接受新的任务；
　　　　4.terminate()：不管任务是否完成，⽴即终⽌；
　　　　5.join()：主进程阻塞，等待⼦进程的退出， 必须在close或terminate之后
　　　　  使⽤；

6.进程间通信-Queue（队列）

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

#coding=utf-8
from multiprocessing import Queue
q=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())    

说明
　　初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最⼤可接收
　　的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到
　　内存的尽头）；
　　　　Queue.qsize()：返回当前队列包含的消息数量；
　　　　Queue.empty()：如果队列为空，返回True，反之False ；
　　　　Queue.full()：如果队列满了，返回True,反之False；
　　　　Queue.get([block[, timeout]])：获取队列中的⼀条消息，然后将其从列队
　　　　中移除，block默认值为True；

7.Queue实例　　

　　我们以Queue为例，在⽗进程中创建两个⼦进程，⼀个往Queue⾥写数据，⼀个从Queue⾥读数据：

from multiprocessing import Process, Queue
import os, time, 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 = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动⼦进程pw，写⼊:
    pw.start()
    # 等待pw结束:
    pw.join()
    # 启动⼦进程pr，读取:
    pr.start()
    pr.join()
    # pr进程⾥是死循环，⽆法等待其结束，只能强⾏终⽌:
    print ''
    print '所有数据都写⼊并且读完'

8.进程池中的Queue

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

#coding=utf-8
#修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random
def reader(q):
    print("reader启动(%s),⽗进程为(%s)"%(os.getpid(),os.getppid()))
    for i in range(q.qsize()):
        print("reader从Queue获取到消息：%s"%q.get(True))
def writer(q):
    print("writer启动(%s),⽗进程为(%s)"%(os.getpid(),os.getppid()))
    for i in "dongGe":
        q.put(i)
if __name__=="__main__":
    print("(%s) start"%os.getpid())
    q=Manager().Queue() #使⽤Manager中的Queue来初始化
    po=Pool()
    #使⽤阻塞模式创建进程，这样就不需要在reader中使⽤死循环了，可以让writer完全执⾏完成后，再⽤reader去读取
    po.apply(writer,(q,))
    po.apply(reader,(q,))
    po.close()
    po.join()
    print("(%s) End"%os.getpid())