python--process

一、守护进程：

借助 daemon=True,必须在被守护的进程开启之前写上 会让被守护的子进程随着主进程的结束而结束

start 开启进程

join 阻塞进

举例守护进程，异步阻塞

import time
from multiprocessing import Process
def func():   #设置要守护的函数
    print('~' * 10)
    time.sleep(15)  #让子进程执行时间是十五秒  ，对比主进程10秒之后，是否会打印 --》 '@'*20
    print('@'*20)   #打印标识；
def compire(): ##设置对比的函数
    while True:    #守护之后，会在主进程10秒之后也跟着结束
        time.sleep(1)
        print('过去1秒')

if __name__=='__main__':
    p=Process(target=func)
    p.daemon=True   #守护第一个子进程
    p.start()     #开启第一个子进程
    c=Process(target=compire)
    c.daemon=True  #守护第二个子进程
    c.start()   #开启第二个子进程
    for i in range(100):
        time.sleep(0.1)
        print('*'*i)    # 让主进程十秒后结束

总结：

"""
   守护进程，就是能够在主进程结束之后，子进程无论是循环还是有其他没有执行的内容，都不会执行了
    如果有两个子进程，只保护其中一个，则两另一个子进程不会守护影响，会继续执行
    进程守护要写在，start 之前
    被守护进程中不能再开启子进程
"""

二、进程中的其他方法：

pid查看进程ip
name查看进程名字
terminate  终结一个进程
is_alive() 查看一个进程是否活着,返回True  False

import os
import time
from multiprocessing import Process
def func(p):   #由于主进程已经关闭了子进程，所以子进程不会再执行了
    print('%s子进程ip'%os.getpid())   #子进程ip



if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.name,p.pid)   #打印进程名字和id  Process-1 8220
    p.name = '进程名改啦'
    print(p.name)   #进程名会更改
    p.terminate()    #异步，主进程发出关闭子进程命令，交给操作系统执行，至于什么时候执行，主进程并不关心，如果操作系统不是立马执行了，下面打印子进程可能还活着。
    print(p.is_alive())      #True
    time.sleep(2)           #睡两秒，操作系统一定是已经执行完了终结命令，下面再判断进程是否活着，就是False
    print(p.is_alive())     #False

三、给进程加锁  lock

# 在异步中，子进程的执行不受主进程是控制，当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。
比如售票系统，在同一时间，多个人（子进程）买一张票，就会造成混乱，这时候就出现了锁的概念

#lock  #由并发变成了串行,牺牲了运行效率,但避免了竞争,保证了数据的安全。
from multiprocessing import Lock   #导入
l=Lock()  #制作一把锁 ，只有一把钥匙
l.acquire()   #需要一把钥匙
l.acquire()   #又需要一把钥匙 但是已经被拿走了，所以会阻塞在这
l.release()   #把钥匙还回去了，别人就可以来取钥匙了

 

from multiprocessing import Lock
from multiprocessing import process
import random
import json
import time
#首先建立一个‘piao’ 的text，手动存入字符串形式的字典{"count":4}  代表有四张火车票
def check_ticket(i):
    with open ('piao','r',encoding='utf-8') as f :
        ret=json.load(f)['count']
        print('%s进来了，还有%d张票'%(i,ret))
def get_ticket(i):
    with open ('piao','r',encoding='utf-8') as f :
        ret = json.load(f)['count']    #读文件夹里，还有几张票
        time.sleep(random.random())
        if ret>0:    #如果还有票，就可以买票
            with open ('piao','w',encoding='utf-8') as f:
                json.dump({'count':ret-1},f)   #每买走一张票，就把文件夹里票的数量减去1
                print('%s买走了一张票,还剩%s张票'%(i,ret-1))
        else:
            print('没有票了')

def task(i,l):     #建立任务子进程
    check_ticket(i)  #检查是谁进来了，还有几张票的
    l.acquire()   #如果还有票，就让他那一把钥匙
    get_ticket(i)   #买走一张票，这时候其他人都在等候
    l.release()  #买完票了还钥匙

# #
if __name__=='__main__':
    l=Lock()   #在建立子进程之前就把锁做好
    for i in range(10):   #循环建立子进程，模拟有10个人一起买票
        p= Process(target=task,args=(i,l))
        p.start()

四、信号量   multiprocess.Semaphoren 是同时允许一定数量的线程更改数据 .也就是可以指定有几把钥匙

from multiprocessing import Semaphore   #导入   ˈseməˌfôr
s=Semaphore(2)      #设置有2把钥匙
s.acquire()     #需要一把钥匙
print(1)      #打印1，说明成功拿走一把钥匙
s.acquire()   #需要一把钥匙
print(2)     #打印2，说明成功拿走一把钥匙
s.release()   #只有还了一把钥匙，下面才能打印出3
s.acquire()   #需要一把钥匙
print(3)    #这里并没有打印出来3  因为只有两把钥匙，当都被拿走了 ，再来拿就会被阻塞  知直到有人还了钥匙

模拟迷你唱吧， 只能容纳四个人，出一个人，才能进一个人

from multiprocessing import Semaphore
from multiprocessing import Process
import random
import time


def sing_bar(i,s):

    s.acquire()
    print('%s进来了'%i)
    time.sleep(random.random())    #随机某个时间，让一个人走
    print('%s走了'%i)
    s.release()
if __name__=='__main__':
    s=Semaphore(4)    #模拟唱吧只能容纳4个人
    for i in range(10):     #模拟十个人一起去唱吧
        p=Process(target=sing_bar,args=(i,s))
        p.start()

五、进程之间的通信：基于IPC(Inter-Process Communication)协议

（1）事件

#事件：是主进程控制  多个  子进程的执行
from multiprocessing import Event    #导入事件
s=Event()   #建立一个信号灯，默认是红灯
s.wait()      #红灯会阻塞
s.set()     #红灯变绿灯
s.clear()   #清除绿灯  -->即绿灯变红灯
s.is_set() # 是否阻塞 True就是绿灯 False就是红灯

#机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时#就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。
#clear：将“Flag”设置为False
#set：将“Flag”设置为True

模拟卡车过红绿灯，卡车是随机来，红绿灯每3秒替换一次

from multiprocessing  import Event
import random
import time
from multiprocessing import Process
def light(e):
    while True:   #让红 绿 灯循环替换
        if e.is_set():  # 是否阻塞 True就是绿灯 False就是红灯
            time.sleep(2)
            e.clear()  # 阻塞              绿变红
            print('红灯亮了')

        else:
            time.sleep(2)
            e.set()  #阻塞变非阻塞              红变绿
            print('绿灯亮了')



def car(i,e):
    e.wait()   #绿灯会通过，红灯就等待
    print('%s车过了' % i)



if __name__=='__main__':
    e=Event()
    p=Process(target=light,args=(e,))   #启动 新线程控制红绿灯
    p.start()
    for i in range(20):      #20辆卡车
        if i%6==0:      #如果整除6 那么就启动一个卡车子进程
            time.sleep(random.randint(1,3))   #启动前 随机等1-3秒
        car_p = Process(target=car, args=(i,e))
        car_p.start()

（2）对列
创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递

from  multiprocessing import Queue  #导入对列，提供get  和 put 方法
put 几个，get几个,get完了就没有了，再get 就会阻塞，且按照put的顺序依次get
q=Queue()
q.put(1)   #往对列里面放
q.put(2)
print(q.get())     # 从对列里往外拿
print(q.get())
q.put(3)
print(q.get())

q=Queue(4)   #可以设置参数，意味着对列里只能放四个值
#q.qsize()   #得出对列长度
#通过队列实现了 主进程与子进程的通信   子进程与子进程之间的通信

from  multiprocessing import Queue
from multiprocessing import Process
import time
def producer(q):
    for i in range(20):   #准备生产20个包子
        q.put('%s个包子'%i)
        print(q)
def consumer(q):
    for i in range(10):   #一个消费者一次get10个包子，吃的速度慢与生产
        time.sleep(1)
        print(q.get())
if __name__=='__main__':
    q=Queue(10)    #设置对托盘（对列）只允许放10个包子
    p=Process(target=producer,args=(q,))
    p.start()
    time.sleep(1)
    c1 = Process(target=consumer, args=(q,))   #一个消费者get十个包子
    c1.start()
    # c2 = Process(target=consumer, args=(q,))   #增加一个消费者，就可以把20个包子吃完，生产和消费就平衡了
    # c2.start()

生产者消费者模型进阶：由于正常情况下，消费者是不知道生产者生产多少，这时候 怎么实现双向通信呢？这里有几种方法：

（1）基于队列实现生产者消费者模型，传递一个成产结束的信号

from  multiprocessing import Queue
from multiprocessing import Process
import time
import random
def producer(q,food):
    for i in range(20):   #两个生产进程准备生产40个包子
        q.put('%s个%s'%(i,food))
        time.sleep(random.random())
    q.put('生产完了')  #生产结束的信号（由于有三个消费者，两个生产者，那么只会产生两个结束的信号，也就是还有一个消费者拿不到结束信号，程序还是没法结束，所以下面还要再设置一个结束信号）
    q.put('生产完了')  # 生产结束的信号
def consumer(q,name):
    while True:#两个消费者 循环消费，直到拿到生产结束的信号
        food=q.get()
        if food =='生产完了':break   #判断拿出来的数据是不是’生产完了‘的信号 ，如果是则说明生产结束，直接退出
        else:
            print(name, food)
if __name__=='__main__':
    q=Queue()
    p1=Process(target=producer,args=(q,'包子'))   #第一个生产者生产20个包子
    p2 = Process(target=producer, args=(q,'馒头'))#第二个生产者生产20个馒头
    p1.start()
    p2.start()
    c1 = Process(target=consumer, args=(q,'zxe'))   #第一个消费者
    c2= Process(target=consumer, args=(q,'zzxxcc'))    # 第二个消费者
    c3 = Process(target=consumer, args=(q, 'zzxxcc'))  # 第三个消费者
    c1.start()
    c2.start()
    c3.start()

"""
对列是安全的
生产者消费者 模型：
    #由于消费者不知道生产者生产多少数据，所以要用while循环
    #循环无法结束，就要生产者给一个结束信号
    #信号数量=消费者的数量-生产者的数量+1，这种方法就略微麻烦了
"""

（2）JoinableQueue 创建可连接的共享进程队列,队列允许项目的使用者通知生产者项目已经被成功处理

# q=JoinableQueue()
# q.get   q.put方法
# q.join  生产者将使用此方法进行阻塞，直到队列中所有项目均被处理。
# q.task_done  使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。

from multiprocessing import JoinableQueue
from multiprocessing import Process

import time
import random

def producer(q,):
    for i in range(5):
        q.put('生产的第%s个包子'%(i))
        time.sleep(random.random())
        q.join()  #直到收到5个task_done信号，才会结束
def consumer(q,name):
    while True:  #由于不知道生产者生产多少，所以用循环来处理不确定的数据
        food=q.get()   #处理数据（消费包子）
        print('%s吃了%s'%(name,food))
        q.task_done()    #每次消费一个包子都会向生产者发送一个task_done

if __name__=='__main__':
    q=JoinableQueue()   #创建可连接的共享进程队列对象
    p=Process(target=producer,args=(q,))
    p.start()
    c1=Process(target=consumer,args=(q,'zxc'))  #要把q对列对象传进去
    c1.daemon=True   #守护进程，因为consumer子进程是一个无线循环的函数，为了让它在处理完数据之后正常结束
    c2=Process(target=consumer,args=(q,'zzxc'))
    c2.daemon = True    #守护进程要写在进程start前面
    c1.start()
    c2.start()
    p.join()   #等待p进程执行完，只要p结束了就代表consumer处理完数据了（如果不加阻塞，主进程会很快执行完了，那么守护进程也会随之结束，而p进程的join 会一直等待task_done  整个程序将无法结束）

总结：生产者生产的数据全部被消费 ——> 生产者进程结束 ——> 主进程代码执行结束 —— >消费者守护进程结束