并发编程： 生产消费模型、死锁与Rlock、线程、守护线程、信号量、锁

一、守护进程

二、互斥锁

三、抢票

四、进程间通讯

五、进程间通讯2

一、守护进程

"""
    进程间通讯的另一种方式 使用queue
    queue  队列
    队列的特点:
        先进的先出
        后进后出
        就像扶梯
"""
from multiprocessing import Process,Queue

# 基础操作 必须要掌握的
# 创建一个队列
# q = Queue()
# # 存入数据
# q.put("hello")
# q.put(["1","2","3"])
# q.put(1)
# # 取出数据
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())

# 阻塞操作 必须掌握
# q = Queue(3)
# # # 存入数据
# q.put("hello",block=False)
# q.put(["1","2","3"],block=False)
# q.put(1,block=False)
# # 当容量满的时候 再执行put 默认会阻塞直到执行力了get为止
# # 如果修改block=False 直接报错 因为没地方放了
# # q.put({},block=False)
#
# # # # 取出数据
# print(q.get(block=False))
# print(q.get(block=False))
# print(q.get(block=False))
# # 对于get   当队列中中没有数据时默认是阻塞的  直达执行了put
# # 如果修改block=False 直接报错 因为没数据可取了
# print(q.get(block=False))

# 了解
q = Queue(3)
q.put("q",timeout=3)
q.put("q2",timeout=3)
q.put("q3",timeout=3)
# 如果满了 愿意等3秒  如果3秒后还存不进去 就炸
# q.put("q4",timeout=3)

print(q.get(timeout=3))
print(q.get(timeout=3))
print(q.get(timeout=3))
# 如果没了 愿意等3秒  如果3秒后还取不到数据 就炸
print(q.get(timeout=3))

二、互斥锁

from multiprocessing import Process,Lock

# 进程间 内存空间是相互独立的
def task1(lock):
    lock.acquire()
    for i in range(10000):
        print("===")
    lock.release()

def task2(lock):
    lock.acquire()
    for i in range(10000):
        print("===============")
    lock.release()

def task3(lock):
    lock.acquire()
    for i in range(10000):
        print("======================================")
    lock.release()

if __name__ == '__main__':
    # 买了一把锁
    mutex = Lock()

    # for i in range(10):
    #     p = Process(target=)
    p1 = Process(target=task1,args=(mutex,))
    p2 = Process(target=task2,args=(mutex,))
    p3 = Process(target=task3,args=(mutex,))

    # p1.start()
    # p1.join()
    # p2.start()
    # p2.join()
    # p3.start()
    # p3.join()

    p1.start()
    p2.start()
    p3.start()

    print("over!")
    # 什么时候用锁?
    # 当多个进程 同时读写同一份数据 数据很可能就被搞坏了
    # 第一个进程写了一个中文字符的一个字节 cpu被切到另一个进程
    # 另一个进程也写了一个中文字符的一个字节
    # 最后文件解码失败
    # 问题之所以出现 是因为并发 无法控住顺序
    # 目前可以使用join来将所有进程并发改为串行

    # 与join的区别?
    # 多个进程并发的访问了同一个资源  将导致资源竞争(同时读取不会产生问题 同时修改才会出问题)
    # 第一个方案 加上join  但是这样就导致了 不公平  相当于 上厕所得按照颜值来
    # 第二个方案 加锁  谁先抢到资源谁先处理[
    # 相同点: 都变成了串行
    # 不同点:
    # 1.join顺序固定 锁顺序不固定!
    # 2.join使整个进程的任务全部串行  而锁可以指定哪些代码要串行

    # 锁使是什么?
    # 锁本质上就是一个bool类型的标识符  大家(多个进程) 在执行任务之前先判断标识符
    # 互斥锁 两个进程相互排斥

    # 注意 要想锁住资源必须保证 大家拿到锁是同一把

    # 怎么使用?
    # 在需要加锁的地方 lock.acquire() 表示锁定
    # 在代码执行完后 一定要lock.release() 表示释放锁
    # lock.acquire()
    # 放需要竞争资源的代码 (同时写入数据)
    # lock.release()

三、抢票

from multiprocessing import Process,Lock

# 进程间 内存空间是相互独立的
def task1(lock):
    lock.acquire()
    for i in range(10000):
        print("===")
    lock.release()

def task2(lock):
    lock.acquire()
    for i in range(10000):
        print("===============")
    lock.release()

def task3(lock):
    lock.acquire()
    for i in range(10000):
        print("======================================")
    lock.release()

if __name__ == '__main__':
    # 买了一把锁
    mutex = Lock()

    # for i in range(10):
    #     p = Process(target=)
    p1 = Process(target=task1,args=(mutex,))
    p2 = Process(target=task2,args=(mutex,))
    p3 = Process(target=task3,args=(mutex,))

    # p1.start()
    # p1.join()
    # p2.start()
    # p2.join()
    # p3.start()
    # p3.join()

    p1.start()
    p2.start()
    p3.start()

    print("over!")
    # 什么时候用锁?
    # 当多个进程 同时读写同一份数据 数据很可能就被搞坏了
    # 第一个进程写了一个中文字符的一个字节 cpu被切到另一个进程
    # 另一个进程也写了一个中文字符的一个字节
    # 最后文件解码失败
    # 问题之所以出现 是因为并发 无法控住顺序
    # 目前可以使用join来将所有进程并发改为串行

    # 与join的区别?
    # 多个进程并发的访问了同一个资源  将导致资源竞争(同时读取不会产生问题 同时修改才会出问题)
    # 第一个方案 加上join  但是这样就导致了 不公平  相当于 上厕所得按照颜值来
    # 第二个方案 加锁  谁先抢到资源谁先处理[
    # 相同点: 都变成了串行
    # 不同点:
    # 1.join顺序固定 锁顺序不固定!
    # 2.join使整个进程的任务全部串行  而锁可以指定哪些代码要串行

    # 锁使是什么?
    # 锁本质上就是一个bool类型的标识符  大家(多个进程) 在执行任务之前先判断标识符
    # 互斥锁 两个进程相互排斥

    # 注意 要想锁住资源必须保证 大家拿到锁是同一把

    # 怎么使用?
    # 在需要加锁的地方 lock.acquire() 表示锁定
    # 在代码执行完后 一定要lock.release() 表示释放锁
    # lock.acquire()
    # 放需要竞争资源的代码 (同时写入数据)
    # lock.release()

四、进程间通讯

"""
    IPC 指的是进程间通讯
        之所以开启子进程 肯定需要它帮我们完成任务 很多情况下 需要将数据返回给父进程
        然而 进程内存是物理隔离的
    解决方案:
    1.将共享数据放到文件中   就是慢
    2.管道   subprocess中的那个  管道只能单向通讯  必须存在父子关系
    3.共享一块内存区域  得操作系统帮你分配  速度快

"""

from multiprocessing import  Process,Manager
import time

def task(dic):
    print("子进程xxxxx")
    # li[0] = 1
    # print(li[0])
    dic["name"] = "xx"

if __name__ == '__main__':
    m = Manager()
    # li = m.list([100])
    dic = m.dict({})
    # 开启子进程
    p = Process(target=task,args=(dic,))
    p.start()
    time.sleep(3)
    print(dic)

五、进程间通讯2

"""
    进程间通讯的另一种方式 使用queue
    queue  队列
    队列的特点:
        先进的先出
        后进后出
        就像扶梯
"""
from multiprocessing import Process,Queue

# 基础操作 必须要掌握的
# 创建一个队列
# q = Queue()
# # 存入数据
# q.put("hello")
# q.put(["1","2","3"])
# q.put(1)
# # 取出数据
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())

# 阻塞操作 必须掌握
# q = Queue(3)
# # # 存入数据
# q.put("hello",block=False)
# q.put(["1","2","3"],block=False)
# q.put(1,block=False)
# # 当容量满的时候 再执行put 默认会阻塞直到执行力了get为止
# # 如果修改block=False 直接报错 因为没地方放了
# # q.put({},block=False)
#
# # # # 取出数据
# print(q.get(block=False))
# print(q.get(block=False))
# print(q.get(block=False))
# # 对于get   当队列中中没有数据时默认是阻塞的  直达执行了put
# # 如果修改block=False 直接报错 因为没数据可取了
# print(q.get(block=False))

# 了解
q = Queue(3)
q.put("q",timeout=3)
q.put("q2",timeout=3)
q.put("q3",timeout=3)
# 如果满了 愿意等3秒  如果3秒后还存不进去 就炸
# q.put("q4",timeout=3)

print(q.get(timeout=3))
print(q.get(timeout=3))
print(q.get(timeout=3))
# 如果没了 愿意等3秒  如果3秒后还取不到数据 就炸
print(q.get(timeout=3))

小结：

1.守护进程 **
    a守护b   b如果死了  a也就跟着死了

2.互斥锁 ******
    为什么使用锁?
    当多个进程对统一资源进行读写时 引发了数据错乱 解决方案就是变成串行
    1.join  把整个进程变成串行  并且顺序时固定的
    2.锁Lock  可以指定哪些代码出串行 并且对资源的竞争是公平的
    本质上就是一个标识符 True 或 False
    多个进程要保证使用同一把锁

3.进程间通讯  ***
    1.文件
    2.管道
    3.共享内存
        Manager  共享列表或字典
        Queue    是一个队列  带有阻塞效果