8.多进程

多进程

• mutiprocessing中的Process，Pool
• subprocess

Process类

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

1. group分组，实际上不使用
2. target表示调用对象，传入任务执行函数作为参数
3. args表示给调用对象以元组的形式提供参数，比如target是函数a，他有两个参数m，n，那么该参数为args=(m, n)即可，只有一个参数时。该参数为args=(m,)
4. kwargs表示调用对象的字典
5. name是别名，相当于给这个进程取一个名字
同时在Process类中提供以下几个方法用于实现进程的操作：

1. start()让进程执行target调用的对象
2. join()起阻塞作用，默认主进程是不会等到子进程结束后结束，需要使用join()使得主进程等待子进程执行结束后结束
3. terminate()结束当前，无论任务是否完成

Process创建多进程

from multiprocessing import Process
import os

def test(i):
    print("---------biubiu--------%s-------%s" %(os.getpid(),os.getpid()))

if __name__=='__main__':
    for i in range(1,20):
        p = Process(target=test,args=(i,))
        print(os.getpid())
        p.start()
        #p.join() 注意观看效果

Pool创建进程池

from multiprocessing import Pool
import os,time,random

def worker(i):
    start = time.time()
    print("%s start,pid is %s" %(i,os.getpid()))
    time.sleep(random.random()*2)#随机休眠0-2秒
    end = time.time()
    print(i,"-----end,run time is %.2f"%(end-start))

if __name__=='__main__':
    #定义一个进程池，最大进程数为4
    p = Pool(4)
    for i in range(0,20):
        p.apply_async(worker,(i,))
    print("----------start------------")
    #关闭进程池,不再接收新的请求
    p.close()
    #等待p中的所有子进程执行完成，必须在close()之后，否则主进程一下就执行结束了
    p.join()
    print("-----------end--------------")

subprocess

import subprocess
print('ping www.baidu.com')
r = subprocess.call(['ping','www.baidu.com'])
print('Exit Code:',r)

Queue

1. Queue.qsize()：返回当前队列包含的消息数量；
2. Queue.empty()：如果队列为空，返回True，反之False；
3. Queue.full()：如果队列满了，返回True,反之False；
4. Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；
5. Queue.get_nowait()：相当Queue.get(False)；
6. Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；
7. Queue.put_nowait(item)：相当Queue.put(item, False)；

from multiprocessing import Queue

#初始一个Queue对象，最多可接收三条put消息
q = Queue(3)
q.put("Msg 1")
q.put('Msg 2')

print(q.full()) #False
q.put('Msg 3')
print(q.full()) #True

try:
    q.put('Msg 4',True,2)
except:
    print("消息队列已满，现有消息数量:%s"%q.qsize())

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

#写消息时，判断是否满了，满了就不写
if not q.full():
    q.put_nowait("Msg 4")

#读消息时，判断是否为空，空了就不读了
if not q.empty():
    for i in range(q.qsize()):
        print(q.get_nowait())

from multiprocessing import Process,Queue
import os,time,random

#写数据进程
def write(q):
    print('Process to write: %s'% os.getpid())
    for i in ['a','b','c']:
        print('Put %s to queue...'% i)
        q.put(i)
        

def read(q):
    print("Process to read: %s"% os.getpid())
    while True:
        if not q.empty():
            i = q.get(True)
            print('Get %s from queue.'% i)
        else:
            break

if __name__ == '__main__':
    #父进程创建Queue,并传给各个子进程
    q = Queue()
    pw = Process(target=write,args=(q,))
    pr = Process(target=read,args=(q,))

    pw.start()
    pr.start()
    pw.join()
    pr.join()
 #看看下图，2个进程同时跑，写进程数据还没写呢，读进程就跑完了

from multiprocessing import Process,Queue
import os,time,random

#写数据进程
def write(q):
    print('Process to write: %s'% os.getpid())
    for i in ['a','b','c']:
        print('Put %s to queue...'% i)
        q.put(i)
        
def read(q):
    print("Process to read: %s"% os.getpid())
    while True:
        if not q.empty():
            i = q.get(True)
            print('Get %s from queue.'% i)
        else:
            break

if __name__ == '__main__':
    #父进程创建Queue,并传给各个子进程
    q = Queue()
    pw = Process(target=write,args=(q,))
    pr = Process(target=read,args=(q,))

    pw.start()
    pw.join()
    pr.start()
    pr.join()
#这样又弄成了串行 

from multiprocessing import Process,Queue
import os,time,random

#写数据进程
def write(q):
    print('Process to write: %s'% os.getpid())
    for i in ['a','b','c']:
        print('Put %s to queue...'% i)
        q.put(i)
        

def read(q):
    print("Process to read: %s"% os.getpid())
    time.sleep(0.00000001)
    while True:
        if not q.empty():
            i = q.get(True)
            print('Get %s from queue.'% i)

        else:
            break

if __name__ == '__main__':
    #父进程创建Queue,并传给各个子进程
    q = Queue()
    pw = Process(target=write,args=(q,))
    pr = Process(target=read,args=(q,))

    pw.start()
    pr.start()
    pw.join()
    pr.join()
#两个进程同时跑，写的肯定慢点，给读进程稍微延迟一点，数据就出来了
#同样的代码廖老师和其他人的教程实现了一行写一行读，想来我cpu比较好吧，直接跑没了