进程

进程

1.开启进程的方式

• 方式1

from multiprocessing import Process
import time
def work(name):
    print('%s is working' %name)
    time.sleep(300)
    print('%s work end' %name)

if __name__ == '__main__':
    # Process(target=work,kwargs={'name':'alex'})
    p=Process(target=work,args=('alex',))
    p.start()
    print('主')

• 方式2

from multiprocessing import Process
import time

class Work(Process):
    def __init__(self,name):
        super().__init__() #重用父类的方法
        self.name=name
    def run(self):
        print('%s is working' %self.name)
        time.sleep(2)
        print('%s work end' %self.name)

if __name__ == '__main__':
    p=Work('wupeiqi')
    p.start()
    print('主')

2.进程之间内存空间隔离

from multiprocessing import Process
n=100
def work():
    global n
    n=0
    print('子',n)

if __name__ == '__main__':
    p=Process(target=work)
    p.start()
    print('主',n)



运行结果为：
主 100
子 0

3.join方法

from multiprocessing import Process
import time
def work(name,n):
    print('%s is working' %name)
    time.sleep(n)
    print('%s work end' %name)

if __name__ == '__main__':
    start_time=time.time()
    p1=Process(target=work,args=('alex',1))
    p2=Process(target=work,args=('wupeiqi',2))
    p3=Process(target=work,args=('yuanhao',3))

    p_l=[p1,p2,p3]
    for p in p_l:
        p.start()
        
    for p in p_l:
        p.join()

    stop_time=time.time()
    print('主',(stop_time-start_time))




运行结果为：
alex is working
wupeiqi is working
yuanhao is working
alex work end
wupeiqi work end
yuanhao work end
主 3.338207483291626

4.进程的其它方法

from multiprocessing import Process
import time
def work(name,n):
    print('%s is listening' %name)
    time.sleep(n)
    print('%s listen end' %name)

if __name__ == '__main__':
    p1=Process(target=work,args=('alex',1))
    p1.start()
    p1.terminate()
    time.sleep(1)
    print(p1.is_alive())
    print('主')
    print(p1.name)
    print(p1.pid)

5.守护进程

#守护进程内不能开子进程
from multiprocessing import Process
import time
def work(n):
    print('>>>start')
    time.sleep(3)
    print(">>>end")
if __name__=='__main__':
    p1=Process(target=work,args=(2,))
    p1.daemon=True
    p1.start()
    time.sleep(5)
    print('主')

# 主进程把代码结束后，子进程也要结束的，这时就应该把子进程设计成守护进程
from multiprocessing import Process
import time
def work(n):
    print('>>>start')
    time.sleep(3)
    print(">>>end")
def talk(m):
    print('>>>s')
    time.sleep(3)
    print(">>>e")
if __name__=='__main__':
    p1=Process(target=work,args=(2,))
    p2= Process(target=talk, args=(3,))
    p1.daemon=True
    p1.start()
    p2.start()
    print('主')

6.互斥锁

（1）join实现串行

#把竞争变得有序，把并发变成串行
from multiprocessing import Process
import os
import time
def task():
    print('%s is running'%os.getpid())
    time.sleep(3)
    print('%s is end' % os.getpid())
if __name__=='__main__':
    p1=Process(target=task)
    p2= Process(target=task)
    p3= Process(target=task)
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    print('main')

（2）互斥锁实现部分进程串行

#模拟抢票
import json
from multiprocessing import Process,Lock
import time
def search(n):
    dic=json.load(open('db'))
    time.sleep(1)
    print('<%s>查询剩余票数[%s]'%(n,dic['count']))
def get(n):
    dic=json.load(open('db'))
    if dic['count']>0:
        dic['count']-=1
        time.sleep(1)
        json.dump(dic,open('db','w'))
        print('<%s>购票成功'%n)
def task(n,lock):
    search(n)
    lock.acquire()
    get(n)
    lock.release()
    # with lock:
    #     get(n)

if __name__=='__main__':
    lock=Lock()
    for i in range(10):
        p1=Process(target=task,args=(i,lock))
        p1.start()

7.队列

from multiprocessing import Queue
q=Queue(3)   # Queue内存中的数据
q.put({'a':1})
q.put('bbbb')
q.put((3,2,1))
q.put_nowait(11111)

print(q.get())
print(q.get())
print(q.get())   #取走之后内存中就没有数据了
print(q.get_nowait())

8.生产者与消费者模型：

（1）程序中有两类角色：一类负责生产数据（生产者），一类负责处理数据（消费者）

（2）引入生产者消费者模型为了解决的问题是：平衡生产者与消费者之间处理数据的响应速度

（3）如何实现：生产者→队列→消费者（生产者消费者解耦合）

from multiprocessing import  Queue,Process
import time,random
def producer(name,q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res=('ddd %s'%i)
        q.put(res)
        print('dd%s生产了%s'%(name,res))
def consumer(name,q):
    while True:
        res=q.get()
        if  res is None:break
        time.sleep(random.randint(1, 3))
        print('%s吃了%s'%(name,res))
if __name__==('__main__'):
    q=Queue()
    p1=Process(target=producer,args=('ww',q))
    p2=Process(target=consumer,args=('bb',q))
    p1.start()
    p2.start()
    p1.join()
    q.put(None)

（4）多生产者多消费者（low版）

from multiprocessing import Queue,Process
import time,random
def producer(name,q,food):
    for i in range(3):
        time.sleep(random.randint(1,3))
        res='%s%s' %(food,i)
        q.put(res)
        print('厨师 %s 生产了 %s' %(name,res))
def consumer(name,q):
    while True:
        res=q.get()
        if res is None:break
        time.sleep(random.randint(1,3))
        print('%s 吃了 %s' %(name,res))

if __name__ == '__main__':
    q=Queue()
    p1=Process(target=producer,args=(1,q,'泔水'))
    p2=Process(target=producer,args=(2,q,'骨头'))
    p3=Process(target=producer,args=(3,q,'馒头'))
    c1=Process(target=consumer,args=('alex',q))
    c2= Process(target=consumer, args=('aa', q))
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()
    q.put(None)
    q.put(None)

（5）用JoinableQueue实现多生产者多消费者

from multiprocessing import JoinableQueue,Process
import time,random
def producer(name,q,food):
    for i in range(3):
        time.sleep(random.randint(1,3))
        res='%s%s' %(food,i)
        q.put(res)
        print('厨师 %s 生产了 %s' %(name,res))
    q.join()
def consumer(name,q):
    while True:
        res=q.get()
        if res is None:break
        time.sleep(random.randint(1,3))
        print('%s 吃了 %s' %(name,res))
        q.task_done()
if __name__ == '__main__':
    q=JoinableQueue()
    p1=Process(target=producer,args=(1,q,'泔水'))
    p2=Process(target=producer,args=(2,q,'骨头'))
    p3=Process(target=producer,args=(3,q,'馒头'))
    c1=Process(target=consumer,args=('alex',q))
    c2= Process(target=consumer, args=('aa', q))
    c1.daemon=True
    c2.daemon = True
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()