守护

守护

关注
发信
关注(28)粉丝(399)

并发编程： 生产消费模型、死锁与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    是一个队列  带有阻塞效果
 
 
 
05-11 23:01
Powered by LMLPHP ©2024 守护 0.052747