进程之multiprocessing模块代码篇

这里再把之前的内容总结和补充一下：

并发和并行：

你在干坏事，来了一个电话，干完坏事再去接电话，说明你既不是并发也不是并行。

你在干坏事，来了一个电话，你接完电话接着干坏事，说明你支持并发

你在干坏事，来了一个电话，你边接电话边干坏事，说明你支持并行

同步和异步：

同步：要想执行下一步 必须等待上一步执行完

异步：想要调用一个函数 只需要通知就行了 不需要等待结果就可以继续执行其他代码

下面简单的来一段代码如何让服务端实现并发的效果

#服务端

import socket
from multiprocessing import Process     
def talk(conn):
    conn.send(b'connected')    #只要客户端一链接就发过去去一条信息
    ret = conn.recv(1024)
    print(ret)
if __name__ == '__main__':
    sk = socket.socket()  
    sk.bind(('127.0.0.1', 8080))
    sk.listen()
    while True:
        conn,addr = sk.accept()
        p = Process(target=talk,args=(conn,))    #在参数传过来实例化一个进程
        p.start()       #开启进程
    conn.close()
    sk.close()

#客户端

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
ret = sk.recv(1024)
print(ret)
msg = input('>>>')
sk.send(msg.encode('utf-8'))
sk.close()
上面的代码只要一直执行客户端就能够实现一个服务端N个客户端的并发效果

start  开启一个进程
join   用join可以让主进程等待子进程结束

守护进程
二话不说上代码

# 守护进程
# 守护进程会随着主进程的代码执行结束而结束
# 正常的子进程没有执行完的时候主进程要一直等着
import time
from multiprocessing import Process
def func():
    print('--'*10)
    time.sleep(15)
    print('--'*10)
def cal_time():      #这个子进程变为了守护进程
    while True:
        time.sleep(1)
        print('过去了1秒')

if __name__ == '__main__':
    p = Process(target=cal_time)
    p.daemon = True     # 一定在开启进程之前设置，此处开启了守护进程
    p.start()
    p2 = Process(target=func)  # 15s
    p2.start()
    for i in range(100):    # 10s
        time.sleep(0.1)
        print('*'*i)
    #p2.join()       #一旦开启join，守护进程也会等待子进程，因为主进程在等待子进程

# 守护进程的进程的作用：
    # 会随着主进程的代码执行结束而结束,不会等待其他子进程
# 守护进程 要在start之前设置
# 守护进程中 不能再开启子进程

import time
from multiprocessing import Process
def func():
    print('wahaha')
    time.sleep(5)
    print('qqxing')
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.is_alive())  
    time.sleep(0.1)
    p.terminate()        # 关闭进程  异步
    print(p.is_alive())  
    time.sleep(1)
    print(p.is_alive())

p.is_alive()   # 是否活着 True代表进程还在 False代表进程不在了
p.terminate()  # 结束一个进程,但是这个进程不会立刻被杀死，由操作系统决定什么时候死

进程的其他方法

属性
pid   查看这个进程 进程id
name  查看这个进程的名字

def func():
    print('wahaha')
    time.sleep(5)
    print('qqxing')
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.name,p.pid)
    p.name = '哇哈哈哈'   #修改了name的名字
    print(p.name)

class MyProcess(Process):
    def run(self):
        print('wahaha',self.name,self.pid)
        time.sleep(5)
        print('qqxing',self.name,self.pid)
if __name__ == '__main__':
    p = MyProcess()
    p.start()
    print(p.pid)

进程中的其他方法
守护进程 p.daemon = True
两个方法 p.is_alive() p.terminate()
两个属性 p.pid p.name

　　　　　　　　　　　　　　　　　　　　　　　　　　锁
在我们费心费力的实现异步并发，提高cpu的利用率的时候，经常会出现多个进程为了抢占输出资源。
锁的存在就是为了梳理这些进程之间的关系

from multiprocessing import Lock   
lock = Lock()    
lock.acquire()  # 需要锁   拿钥匙
lock.acquire()  # 需要锁   连续两次拿钥匙阻塞

lock.release()  # 释放锁  还钥匙

锁 就是在并发编程中 保证数据安全

下面模拟一下春运抢票

import json
import time
import random
from multiprocessing import Lock
from multiprocessing import Process
def search(i):
    with open('ticket') as f:            #打开一个ticket文件，里面存放了{"count": 0}
        print(i,json.load(f)['count'])   #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
def get(i):
    with open('ticket') as f:
        ticket_num = json.load(f)['count']
        time.sleep(random.random())    #时间在这里停了大于0且小于1之间的小数
        if ticket_num>0:      #如果文件中的count对应的值大于0
            with open('ticket','w') as f:
                json.dump({'count':ticket_num-1},f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
            print('%s买到票了'%i)      #打印结果并且数量减一
        else:
            print('%s没票了'%i)
def task(i,lock):
    search(i)           #查票
    lock.acquire()      #拿到一把锁
    get(i)              #抢票
    lock.release()      #释放锁
if __name__ == '__main__':
    lock = Lock()   #实例化一把锁
    for i in range(20):   #20个人同时抢票
        p = Process(target=task,args=(i,lock))       #实例化一个进程对象
        p.start()       #执行这个进程

信号量

import time
import random
from multiprocessing import Semaphore
from multiprocessing import Process
def sing(i,sem):
    sem.acquire()
    print('%s : 进入 ktv'%i)
    time.sleep(random.randint(1,10))
    print('%s : 出 ktv'%i)
    sem.release()
# 迷你唱吧  20个人，同一时间只能有4个人进去唱歌
if __name__ == '__main__':
    sem = Semaphore(4)     #这里限制了一次最多几个进程执行
    for i in range(20):
        Process(target=sing,args=(i,sem)).start()

事件

所有的阻塞 都是同步
recv accept input sleep
阻塞多个进程  异步阻塞
事件 —— 异步阻塞
事件 标志 同时 是所有的进程 都陷入阻塞
from multiprocessing import Event   #事件
e = Event() # 实例化一个事件  标志/交通信号灯
e.set()     # 将标志变成非阻塞/交通灯变绿
e.wait()    # 刚实例化出来的一个事件对象，默认的信号是阻塞信号/默认是红灯，执行到wait，要先看灯，绿灯行红灯停，如果在停的过程中灯绿了，就变成非阻塞了
e.is_set()是否非阻塞 True就是绿灯 False就是红灯

下面就举例马路上的红绿灯来看一下事件

import time
import random
from multiprocessing import Process
from multiprocessing import Event
def traffic_light(e):
    while True:
        if e.is_set():     #判断是红灯还是绿灯
            time.sleep(3)
            print('红灯亮')
            e.clear()      # 绿变红
        else:
            time.sleep(3)
            print('绿灯亮')
            e.set()        # 红变绿
def car(i,e):
    e.wait()
    print('%s车通过'%i)
if __name__ == '__main__':
    e = Event()   # 立一个红灯
    tra = Process(target=traffic_light,args=(e,))
    tra.start()   # 启动一个进程来控制红绿灯
    for i in range(100):
        if i%6 == 0 :
            time.sleep(random.randint(1,3))
        car_pro = Process(target=car, args=(i,e))
        car_pro.start()

通过上述代码可以看出，Event模块的作用就是通过判断是否阻塞然后来改变阻塞状态来实现自己想要的效果

队列

it行业当中总会有一些莫名其妙的需求，这是一种钻研精神。比如，现在某个人有一种想法，能不能实现两个进程之间的通话呢？

from multiprocessing import Queue
q = Queue(2)    #这里不传参数就会默认数据长度无限制，现在限制最多只能放两个值，如果放三个值是放不进去的
q.put(1)
q.put(2)
q.put(3)      #put（）是放数据，现在放了三个
print(q.get())
print(q.get())
print(q.get())  # get（）往外拿值
print(q.get())  # 前面一共放了三个值，如果队列里已经没有值了 就会阻塞等待有一个值

1.进程之间通信 可以使用multiprocessing 的 Queue模块
2.队列有两种创建方式 第一种不传参数 这个队列就没有长度限制 ；如果传参数，则创建一个有最大长度限制的队列
3.提供两个重要方法；put get

from multiprocessing import Process
from multiprocessing import Queue
import random
def q_put(q):  
    q.put('hello')   #往队列里放值
def q_get(q):
    print(q.get())   #从队列里拿值
if __name__ =='__main__':
    q = Queue()
    p = Process(target=q_put,args=(q,))
    p.start()
    p1 = Process(target=q_get, args=(q,))
    p1.start()
上面代码通过队列实现了，主进程与子进程的通信，子进程与子进程之间的通信

生产者消费者模型
我要生产一个数据 然后 给一个函数 让这个函数依赖这个数据进行运算  拿到结果  —— 同步过程
下面来一个做包子和吃包子的例子
import time
def producer(q):  # 生产者
    for i in  range(100):
        q.put('包子%s'%i)  #生产者生产包子

def consumer(q): #  消费者
    for i in range(100):
        time.sleep(1)
        print(q.get())   #消费者买包子

if __name__ == '__main__':
    q = Queue(10)   # 生产者做好的包子放在这里，一次放十个
    p = Process(target=producer,args=(q,))
    p.start()
    c1 = Process(target=consumer, args=(q,))
    c2 = Process(target=consumer, args=(q,))   #一个人买的太慢，再实例化一个消费者
    c1.start()
    c2.start()

首先 对于内存空间来说 每次只有很少的数据会在内存中
对于生产与消费之间的不平衡来说
    增加消费者或者增加生产者来调节效率