打印

打印

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

并发编程----互斥锁 队列 消费者模型

互斥锁 队列 消费者模型

一,互斥锁

  • 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争,竞争带来的结果就是错乱,如何控制,就是加锁处理

  • 并发运行,效率高,但竞争同一打印终端,带来了打印错乱

    from multiprocessing import Process
import time
import random
def task1():
    print('task1开始打印')
    time.sleep(random.randint(1, 3))
    print('task1打印完成')

def task2():
    print('task2开始打印')
    time.sleep(random.randint(1, 3))
    print('task2打印完成')

def task3():
    print('task3开始打印')
    time.sleep(random.randint(1, 3))
    print('task3打印完成')

if __name__ == '__main__':
    p1 = Process(target=task1)
    p2 = Process(target=task2)
    p3 = Process(target=task3)
    p1.start()
    p2.start()
    p3.start()

# 多个进程共抢一个资源,你要是做到结果第一位,效率第二位
# 此时应该牺牲效率,保求结果,串行.

  • 串行: 保证了顺序,但是没有实现公平

    # 版本二,串行
from multiprocessing import Process
import time
import random
def task1():
    print('task1开始打印')
    time.sleep(random.randint(1, 3))
    print('task1打印完成')

def task2():
    print('task2开始打印')
    time.sleep(random.randint(1, 3))
    print('task2打印完成')

def task3():
    print('task3开始打印')
    time.sleep(random.randint(1, 3))
    print('task3打印完成')

if __name__ == '__main__':
    p1 = Process(target=task1)
    p2 = Process(target=task2)
    p3 = Process(target=task3)
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
# 虽然说上面的版本完成了串行结果,保证了顺序,但是没有实现公平
# 问题: 顺序事先设定,我们要做到他们公平的去抢占打印机资源,谁先抢到,先执行谁

  • 加锁: 由并发变成了串行,牺牲了运行效率,但避免了竞争

    # 版本三,锁
from multiprocessing import Process
from multiprocessing import Lock
import time
import random
def task1(lock):
    lock.acquire()
    print('task1开始打印')
    time.sleep(random.randint(1, 3))
    print('task1打印完成')
    lock.release()

def task2(lock):
    lock.acquire()
    print('task2开始打印')
    time.sleep(random.randint(1, 3))
    print('task2打印完成')
    lock.release()

def task3(lock):
    lock.acquire()
    print('task3开始打印')
    time.sleep(random.randint(1, 3))
    print('task3打印完成')
    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()
------------------------------------------------------------------
执行结果:
    task1开始打印
    task1打印完成
    task2开始打印
    task2打印完成
    task3开始打印
    task3打印完成

# 上锁: 一定要是同一把锁,上锁一次,解锁一次

  • 死锁:上锁一次,又上锁一次

    # 死锁: 上锁一次,又上锁一次
from multiprocessing import Process
from multiprocessing import Lock
import time
import random
def task1(lock):
    lock.acquire()
    lock.acquire()
    print('task1开始打印')
    time.sleep(random.randint(1, 3))
    print('task1打印完成')
    lock.release()

def task2(lock):
    lock.acquire()
    print('task2开始打印')
    time.sleep(random.randint(1, 3))
    print('task2打印完成')
    lock.release()

def task3(lock):
    lock.acquire()
    print('task3开始打印')
    time.sleep(random.randint(1, 3))
    print('task3打印完成')
    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()

  • 验证: 上锁后,遇到IO阻塞cup也会切换,但是发现需要同一把锁就不会执行

    from multiprocessing import Process
from multiprocessing import Lock
import time
import random
def task1(lock):
    lock.acquire()
    print('task1开始打印')
    time.sleep(random.randint(1, 3))
    print('task1打印完成')
    lock.release()

def task2(lock):
    print('task2')
    lock.acquire()
    print('task2开始打印')
    time.sleep(random.randint(1, 3))
    print('task2打印完成')
    lock.release()

def task3(lock):
    print('task3')
    lock.acquire()
    print('task3开始打印')
    time.sleep(random.randint(1, 3))
    print('task3打印完成')
    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()

  • 模拟抢票系统: 文件版

    # db文件内容: {"count": 80}
from multiprocessing import Process
from multiprocessing import Lock
import time
import random
import json
import os

def search():
    time.sleep(random.random())
    dic = json.load(open('db'))
    print(f'剩余票数:{dic["count"]}')

def get():
    dic = json.load(open('db'))
    time.sleep(random.random())
    if dic['count'] > 0:
        dic['count'] -= 1
        time.sleep(random.random())
        json.dump(dic, open('db', 'w'))
        print(f'{os.getpid()}用户购票成功')
    else:
        print('没票了......')
def task(lock):
    search()
    lock.acquire()
    get()
    lock.release()
if __name__ == '__main__':
    lock = Lock()
    for i in range(100):
        p = Process(target=task, args=(lock,))
        p.start()

  • 互斥锁与join的区别与共同点

    • 共同点: 都完成了进程之间的串行
    • 区别: join人为控制的进程串行,互斥锁是随机的抢占资源,保证了公平性

  • 思考

    # 加锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即串行的修改,没错,速度是慢了,但牺牲了速度却保证了数据安全.
虽然可以用文件共享数据实现进程间通信,但问题是:
1.效率低(共享数据基于文件,而文件是硬盘上的数据)
2.需要自己加锁处理

# 因此我们最好找寻一种解决方案能够兼顾:1、效率高(多个进程共享一块内存的数据)2、帮我们处理好锁问题.这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制:队列和管道.
队列和管道都是将数据存放于内存中
队列又是基于(管道+锁)实现的,可以让我们从复杂的锁问题中解脱出来,我们应该尽量避免使用共享数据,尽可能使用消息传递和队列,避免处理复杂的同步和锁问题,而且在进程数目增多时,往往可以获得更好的可获展性

二, 队列

  • 进程彼此之间互相隔离,要实现进程间通信(IPC),multiprocessing模块支持两种形式：队列和管道,这两种方式都是使用消息传递的

  • 队列就是存在于内存中的一个容器,最大的一个特点:队列的特性就是FIFO,完全支持先进先出的原则.

  • 创建队列的类(底层就是以管道和锁定的方式实现):

    • Queue([maxsize]):创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递.
    • maxsize是队列中允许最大项数,省略则无大小限制.

  • 方法介绍:

    1 q.put方法用以插入数据到队列中,put方法还有两个可选参数: blocked和timeout.如果blocked为True(默认值),并且timeout为正值,该方法会阻塞timeout指定的时间,直到该队列有剩余的空间.如果超时,会抛出Queue.Full异常.如果blocked为False,但该Queue已满,会立即抛出Queue.Full异常
2 q.get方法可以从队列读取并且删除一个元素.同样,get方法有两个可选参数: blocked和timeout.如果blocked为True(默认值),并且timeout为正值,那么在等待时间内没有取到任何元素,会抛出Queue.Empty异常.如果blocked为False,有两种情况存在,如果Queue有一个值可用,则立即返回该值,否则,如果队列为空,则立即抛出Queue.Empty异常.
3 q.get_nowait(): 同q.get(False)
4 q.put_nowait(): 同q.put(False)
5 q.empty(): 调用此方法时q为空则返回True,该结果不可靠,比如在返回True的过程中,如果队列中又加入了项目
6 q.full(): 调用此方法时q已满则返回True,该结果不可靠,比如在返回True的过程中,如果队列中的项目被取走
7 q.qsize(): 返回队列中目前项目的正确数量,结果也不可靠,理由同q.empty()和q.full()一样

  • 利用队列进行进程之间通信: 简单,方便,不用自己手动加锁,队列自带阻塞,可持续化取数据

    from multiprocessing import Queue
q = Queue(3)  # 可以设置元素个数

def func():5
    print('in func')
q.put('asd')
q.put({'count': 1})
q.put(func)
# q.put(func)  # 当队列的数据已经达到上限,再插入数据的时候,程序就会夯住
print(q.get())
print(q.get())
print(q.get())
print(q.get())  # 当队列的数据已经取空,再取数据的时候,程序就会夯住
---------------------------------------------------
# 模拟一个实例
# 小米: 抢手环4  预发售10个
# 有100个人去抢
from multiprocessing import Process
from multiprocessing import Queue
import os
def tack(q):
    try:
        q.put(f'{os.getpid()}用户', block=False)
    except Exception:
        return False

if __name__ == '__main__':
    q = Queue(10)
    for i in range(100):
        p = Process(target=tack, args=(q,))
        p.start()

    for el in range(1, 11):
        print(f'第{el}个用户:', q.get())

  • 生产者消费者模型

    • 在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题.该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度.

    • 为什么要使用生产者和消费者模式
      在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程.在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据.同样的道理,如果消费者的处理能力大于生产者,那么消费者就必须等待生产者.为了解决这个问题于是引入了生产者和消费者模式.

    • 基于队列实现生产者消费者模型

      # 以吃包子举例,厨师生产出包子,不可能塞你嘴里,放在一个盆中
# 三个主体: (生产者)厨师,(容器队列)盆,(消费者)吃包子的人
# 如果没有容器,生产者与消费者强耦合型,所以要有一个容器,缓冲区.平衡了生产力与消费力
# 生产者消费者模型多应用与并发
from multiprocessing import Process
from multiprocessing import Queue
import time
import random
import os

def producer(q):
    for i in range(1, 11):
        res = f'包子{i}'
        time.sleep(random.randint(1, 3))
        q.put(res)
        print(f'生产者{os.getpid()}制作了{res}')

def consumer(q):
    while 1:
        try:
            res = q.get(timeout=4)
            time.sleep(random.randint(1, 3))
            print(f'消费者{os.getpid()}吃了{res}')
        except Exception:
            break

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=consumer, args=(q,))
    p2 = Process(target=producer, args=(q,))
    p1.start()
    p2.start()

# 生产者消费者模型:
# 合理的调控多个进程去生产数据以及提取数据,中间有个必不可少的环节(容器队列)

三, 管道

  • 进程间通信(IPC)方式二: 管道
    #创建管道的类：
Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道
#参数介绍：
dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。
#主要方法：
    conn1.recv():接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
    conn1.send(obj):通过连接发送对象。obj是与序列化兼容的任意对象
 #其他方法：
conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法
conn1.fileno():返回连接使用的整数文件描述符
conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。

conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。
conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收

conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。
    from multiprocessing import Process,Pipe

import time,os
def consumer(p,name):
    left,right=p
    left.close()
    while True:
        try:
            baozi=right.recv()
            print('%s 收到包子:%s' %(name,baozi))
        except EOFError:
            right.close()
            break
def producer(seq,p):
    left,right=p
    right.close()
    for i in seq:
        left.send(i)
        # time.sleep(1)
    else:
        left.close()
if __name__ == '__main__':
    left,right=Pipe()

    c1=Process(target=consumer,args=((left,right),'c1'))
    c1.start()


    seq=(i for i in range(10))
    producer(seq,(left,right))

    right.close()
    left.close()

    c1.join()
    print('主进程')

# 基于管道实现进程间通信（与队列的方式是类似的，队列就是管道问题的，管道会造成数据的不安全，官方给予的解释是管道有可能会造成数据损坏。
12-18 19:50
Powered by LMLPHP ©2024 打印 0.067551