并发编程：生产消费模型、死锁与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    是一个队列带有阻塞效果

巴特西

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

最新文章

热门文章

巴特西

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

最新文章

热门文章

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