9.16(day37)进程锁，队列(Queue),JoinableQueue用法，初识线程

进程锁

lock.acquire() 锁住

lock.release() 释放锁头

进程锁：把锁住的代码变成串行

join:把全部代码变成串行

为了保证数据的安全，串行牺牲掉效率

队列(Queue)

队列：pipe+锁 Queue(不适合传大文件，通常传一些消息)

ipc机制：进程通讯

管道：pipe基于共享的内存空间

具体用法:
from multiprocessing import Process,Queue

q = Queue()   # 空队列，可放数字控制队列大小，
q.put('zhang')
q.put('jian')   # 放入，超过队列大小是会阻塞
# q.put(对象，block=True,timeout=)   第一个参数为放入的数据，第二个参数默认为True,表示如果放入的时候满了等待，timeout控制阻塞时间，单位秒，超过时间没有执行会报错

q.get()
q.get()
q.get()   # 取值，没有的时候回等待，会阻塞
q.get(对象，block=True,timeout=)   第一参数数据，第二参数表示没有东西会等待，timeout等待时间，超过没有去处东西会报错

block = False,当放入是队列满了，或者去时队列空了直接报错

q.get_nowait()    表示不等待，相当于q.get(block = False,)
q.put_nowait()    表示不等待，相当于q.put(block = False,)

生产者消费者模型

生产者：生产数据

消费者：处理数据

生产者---队列---消费者

生产者可以不停的生产达到在自己最大的生产效率

生产者消费者模型提高了生产者生产的效率和

第一代
from multiprocessing import Process, Queue

def producer(q,name,food):
    for i in range(10):
        print(f'{name}生产了{food}{i}')
        res = f'{food}{i}'
        q.put(res)
    q.put(None)


def consumer(q,name):
    while True:
        res = q.get(timeout=5)
        if res is None:
            break
        print(f'{name}吃了{res}')


if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer, args=(q, 'zjh', '包子'))
    c1 = Process(target=consumer,args=(q,'zj'))
    p1.start()
    c1.start()
    q.put(None)

第二代
from multiprocessing import Process,Queue
import time,random
def producer(q,name,food):
    for i in range(3):
        print(f'{name}生产了{food}{i}')
        time.sleep(random.randint(1,3))
        res = f'{food}{i}'
        q.put(res)

def consumer(q,name):
    while True:
        res = q.get(timeout = 5)
        if res is None:
            break
        time.sleep(random.randint(1,3))
        print(f'{name}吃了{res}')

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer(q,'lqz','baozi'))
    p2 = Process(target=producer(q,'nick','xie'))
    p3 = Process(target=producer(q,'rockey','dabing'))
    c1 = Process(target=consumer(q,'qxp'))
    c2 = Process(target=consumer(q,'dgq'))
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()
    q.put(None)
    q.put(None)

第三代
from multiprocessing import Process,Queue,JoinableQueue
import time,random

def producer(q,name,food):
    for i in range(3):
        print(f'{name}生产了{food}{i}')
        time.sleep(random.randint(1,3))
        res = f'{food}{i}'
        q.put(res)

def consumer(q,name):
    while True:
        res = q.get()
        time.sleep(random.randint(1,3))
        print(f'{name}吃了{res}')
        q.task_done()

if __name__ == '__main__':
    q = JoinableQueue()
    p1 = Process(target=producer, args=(q, 'rocky', '包子'))
    p2 = Process(target=producer, args=(q, 'mac', '韭菜'))
    p3 = Process(target=producer, args=(q, 'nick', '蒜泥'))
    c1 = Process(target=consumer, args=(q, '成哥'))
    c2 = Process(target=consumer, args=(q, '浩南哥'))
    p1.start()
    p2.start()
    p3.start()
    c1.daemon = True
    c2.daemon = True
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()
    q.join()

JoinableQueue用法

from multiprocessing import Process,Queue,JoinableQueue

q = JoinableQueue()
q.put('zhang')   # 放入一次任务
q.put('jian')
print(q.get())
q.task_done()    # 完成了一次任务
print(q.get())
q.task_done()
q.join()   # 计数器不为0时，阻塞等待计数器为0

初识线程

线程：代码的运行过程，cpu最小的执行单位

传统操作系统中，每个进程都有一个地址空间，而且默认就有一个控制线程

在工厂中，每个车间都有房子，每个车间默认就有一条流水线

操作系统---工厂

进程---车间(线程加资源单位)

线程---(流水线)

cpu---(电源)

线程执行 = 运行代码

进程：资源集合，资源单位

进程运行 = 各种资源+线程