守护进程,进程安全,IPC进程间通讯,生产者消费者模型

1.守护进程(了解)
2.进程安全(*****)
    互斥锁
    抢票案例
3.IPC进程间通讯
    manager
    queue(*****)
4.生产者消费者模型
 
守护进程
    指的也是一个进程,可以守护着另一个进程
    一个进程a 设置为b的守护进程 当b结束时 a会立马结束自己 不管任务是否执行完毕
    使用场景: 例如qq进程 有一个下载任务 交给了一个子进程 但是过程中 qq退出了 下载进程也可以随之关闭了
 
   *** p.daemon=True  将p子进程设置为主进程的守护进程 必须放在开启进程之前设置***
 
进程安全问题
当多个进程要同时操作同一个资源时,就可能出现问题
例如:
    只有一台答应机大那会很多打印任务 如果不加以控制 可能造成打印结果错乱
解决方案1:加 join  把原本并发的任务变成串行执行
        但是如此一来 进程与顺序就不再平等 顺序已经固定死
最终的解决方案就是加锁
    使用Lock来实例化产生一把锁
    但是要保证每个进程访问的都是同一把锁
    在访问共享资源前 加锁
    访问完毕后一定要解锁
    不能多次执行acquire 一次acquire对应一次release
    acquire 是一个阻塞函数 会一直等到锁被释放(release调用)才会继续执行
 
lock=Lock()
lock.acquire() 锁定
lock.release() 解锁

# from multiprocessing import Process,Lock
# import time,random
#
# def task1(lock):
#     lock.acquire()
#     print('惺惺相惜想')
#     time.sleep(random.randint(1,2))
#     lock.release()
#
#
# def task2(lock):
#     lock.acquire()
#     print('xxx')
#     time.sleep(random.randint(1, 2))
#     lock.release()
#
# def task3(lock):
#     lock.acquire()
#     print('1234')
#     time.sleep(random.randint(1, 2))
#     lock.release()
#
#
# if __name__ == '__main__':
#     lock=Lock()
#     p1=Process(target=task1,args=(lock,))
#     p2 = Process(target=task2, args=(lock,))
#     p3 = Process(target=task3, args=(lock,))
#
#     p1.start()
#     p2.start()
#     p3.start()

加锁

 
加锁之后 并发又变成了串行了 不过与join不同的是 没有规定顺序 谁先抢到谁先执行
 
问题:一旦加锁 效率降低 不加锁数据要错乱
 
在使用锁的时候 无可避免的会降低效率
需要找到一个最合适的地方加上锁
你锁住的代码越少效率越高
 
join是让整个进程中的代码全部串行 而锁可以部分代码串行
粒度(被锁住的代码量)越小 效率越高
 
互斥锁:互相排斥其他进程
 
IPC 进程间通讯
    进程与进程之间 内存是物理隔离的 无法直接通讯
 
1.使用一个交换文件 在硬盘上创建一个文件 不同进程之间共享这个文件
    优点:交换的数据量几乎没有限制
    缺点:速度慢
2.系统开辟一块共享内存 来供进程间交换数据
    优点:速度快
    缺点:交换的数据量不能太大
3.管道
    优点:封装了文件的打开 关闭等操作
    缺点:速度慢 单向传输 编程的复杂度较高
4.socket
    不仅可用于与远程计算机中的进程通讯 还可以用于与本地进程通讯
    基于内存的速度快

# from multiprocessing import  Process,Manager,Lock
#
# import time
#
#
#
# def task(dic,lock):
#     lock.acquire()
#     i = dic["num"]   # 3  3  3
#     time.sleep(0.3) #2  2  2
#     dic["num"] = i - 1
#     lock.release()
#
# if __name__ == '__main__':
#     # 共享内存管理器
#     m = Manager()
#     # 在共享内存区域 创建了一个字典
#     dic = m.dict({"num":3})
#
#     lock = Lock()
#     # 将处于共享内存区域的字典传给子进程
#     p =Process(target=task,args=(dic,lock))
#     p1 = Process(target=task, args=(dic,lock))
#     p2 = Process(target=task, args=(dic,lock))
#
#
#     p.start()
#     p1.start()
#     p2.start()
#
#     p.join()
#     p1.join()
#     p2.join()
#
#
#
#     print(dic["num"])

IPC

Manager 共享内存管理器
开启一个共享的内存区域  可以是列表 字典 array数组
没有处理进程安全问题 需要自己加锁

queue 队列也是一个容器
    特点:先进先出
        支持进程间共享
        自动出来了进程安全问题(加锁)
    例如:迅雷下载 先添加的任务一定先开始执行
 
堆栈:
    特点:先进后出
    例如:函数的执行 吃薯片 最上面的最先吃
 
put（）会阻塞，直到队列里面有位置为止
get（）也会阻塞，直到队里里面有数据为止
put（obj,block=True，timeout），block为阻塞的意思，默认为阻塞状态，
timeout等待超时，只有在block为True时有效

# from multiprocessing import  Process,Manager,Queue
#
# import time
#
#
#
# def task(q):
#     num = q.get() # 3
#     time.sleep(0.5)
#     q.put(num-1)
#
#
# if __name__ == '__main__':
#
#     q = Queue()
#     q.put(3)
#     # 将处于共享内存区域的字典传给子进程
#     p =Process(target=task,args=(q,))
#     p1 = Process(target=task, args=(q,))
#     p2 = Process(target=task, args=(q,))
#
#
#     p.start()
#     p1.start()
#     p2.start()
#
#     p.join()
#     p1.join()
#     p2.join()
#
#
#
#     print(q.get())

QUE队列

 
生产者消费者模型
    模型即解决某个问题的套路
    问题:
        生产者负责产生数据
        消费者处理数据
        当消费者与生产者的能力不匹配时,必须一放要等待另一方 这样效率就变低了
 
    1.将原本由同一个进程完成的 两个(生产和消费) 拆分为两个不交给两个不同的角色(进程)来完成
    2.由于进程间内存相互隔离 所以需要为两个角色之间提供一个共享的数据容器
    3.生产 将生产完成的数据 放入容器中
    4.消费者从 容器中取出数据来处理
 
    生产者消费者模型的优点:
        1.平衡了生产者和消费者之间的能力差异 提高处理效率
        2.降低了双方耦合度
 
    学习并发 的两个核心问题 安全性 和 效率

from multiprocessing import  Process,Queue
import time,random
 
# 生产者
def xiaomi_factory(name,q):
    for i in  range(1,6):
        time.sleep(random.randint(1,3))
        phone = "这是%s生产的 小米9_%s" % (name,i)
        print("生产者 生产了%s" % phone)
        # 方到柜台 即 存储到队列中
        q.put(phone)
 
# 消费者
def buy_mi9(q):
    for i in range(10):
        # 从队列中取出需要被处理的数据(phone)
        time.sleep(random.randint(1, 2))
        phone = q.get()
        print("消费者 消费了%s" % phone)
 
if __name__ == '__main__':
    # 共享数据的队列
    q = Queue()
 
    # 生产者
    p1 = Process(target=xiaomi_factory,args=("北京公司",q))
    p2 = Process(target=xiaomi_factory,args=("上海公司",q))
    p1.start()
    p2.start()
 
    # 消费者
    c1 = Process(target=buy_mi9,args=(q,))
    c1.start()

生产者消费者模型