'''
生产者消费模型
'''
from threading import Thread
from time import sleep
from queue import Queue


def producer():
    num = 1
    while mq.not_empty:
        print("王大娘做了第{}个包子".format(num))
        mq.put(f"王大娘做的第{num}个包子")
        num += 1
        sleep(2)
    else:
        print("吃的太快了")


def consumer(name, count):
    while mq.not_empty:
        m = mq.get()
        print("{}吃了第{}个包子".format(name, m))
        sleep(count)
    else:
        sleep(5)

if __name__ == '__main__':
    mq = Queue()
    t1 = Thread(target=producer)
    t2 = Thread(target=consumer, args=("张三", 3))
    t3 = Thread(target=consumer, args=("李四", 1))
    t4 = Thread(target=consumer, args=("王五", 1))
    t1.start()
    t2.start()
    t3.start()
    t4.start()

老师，我这包子两秒钟做一个，但是吃包子的最快一秒一个，为啥生产者中的print("吃的太快了")没有执行，还是做一个吃一个

from greenlet import greenlet
from time import time
def func1():
    num=0
    for i in range(10000000):
        num += 1
        g2.switch()
def func2():
    num=0
    for i in range(10000000):
        num += 1
        g1.switch()
if __name__ =="__main__":
    g1=greenlet(func1)
    g2=greenlet(func2)
    start=time()
    end=time()
    print(end-start)

老师 我这个代码哪有问题 一值运行不出来

from time import sleep
def consumer():
    for i in range(6):
        print(f"生产了第{i}个产品")
        yield
        
def producter():
    g= consumer()
    next(g)
    for i in range(5):
        print(f"消费了第{i}个产品")
        next(g)
if __name__ == "__main__":
    producter()

老师 这个消费者与生产者这样 也可以实现啊  为什么得用send

老师 执行第7行之后 就跳到func1这个函数里开始执行  执行到第4行的时候 卡住了 

然后跳到第8行 第8行接收了第3行的北京打印第0次数据   存储起来

接着开始执行第9行 第10行 

第11行 接着上次存储的 继续开始打印 北京打印第1次数据 

然后回到第9行 在开始新的一轮循环 

这个是这样理解吗 老师

老师 还有视频中说协程自身带有上下文和栈 这个怎么理解？ 

老师 对于协程是怎么工作的 还是有些不理解 例如这里有个单线程 它里边创建了3个协程  但是现在这里有5个任务  那这三个协程是怎么工作的   

请问协程不是在IO的时候会切换到另一任务吗，为什么缺点里却又会阻塞整个程序？ 老师 这样把这个问题解释详细一点吗 

老师 关于这个协程  视频中老师讲的遇到IO就会停止运行 或者切换到下一个任务 这个IO是指什么

import os
from multiprocessing import Pool
from time import sleep

def func1(name):
    print(f"当前的进程ID:{os.getpid()},{name}")
    sleep(3)
if __name__ =="__main__":
    pool=Pool(5)
    pool.apply_async(func=func1,args=("jhy1",))
    pool.apply_async(func=func1,args=("jhy2",))
    pool.apply_async(func=func1,args=("jhy3",))
    pool.apply_async(func=func1,args=("jhy4",))
    pool.apply_async(func=func1,args=("jhy5",))
    pool.apply_async(func=func1,args=("jhy6",))
    pool.apply_async(func=func1,args=("jhy7",))
    pool.apply_async(func=func1,args=("jhy8",))

    pool.close()
    pool.join()

老师 关于这个进程池就是 池子里一共有5个进程 然后来了8个任务 每个任务都是去调用func1这个函数   先是5个去执行 然后是剩下的3个去执行  这些进程之间是异步执行  同时在进行  不用回收 不用开辟空间 这样节省效率  这样理解对吗

from multiprocessing import Process,current_process 
import os
from multiprocessing import Manager

def func1(name,m_dict,m_list):
    print("子进程ID{}获取了数据：{}".format(os.getpid(),m_list))
    print("子进程ID{}获取了数据：{}".format(os.getpid(),m_dict))
    m_list.append("姬昊余") #这里可以从子进程中往主进程里写
    m_dict["你好"]="吕倩倩"
if __name__=="__main__":
    print("主进程ID：{}".format(current_process().pid))
    #print("进程ID：{}".format(os.getpid()))
    with Manager() as mgr: #开启一个网络的端
        m_list=mgr.list() #创建一个列表
        m_dict=mgr.dict() #创建一个字典
        m_list.append("hello") #列表中添加数据
        p1=Process(target=func1,args=("p1",m_dict,m_list)) #也需要将容器传给子进程  
        p1.start()
        p1.join()
        print(m_dict)
        print(m_list)

老师 关于这个with 这里为什么要使用with 有点不理解 为什么不能之间创建共享数据对象

from threading import Thread
from queue import Queue
from time import sleep
def produce():
    num=1
    while True:
        if mq.qsize()<10:  #控制数量
            print(f"生产了{num}号加菲猫")
            mq.put(f"{num}号加菲猫")
            num +=1 
        sleep(1)
def consumer():
    while True:
        print("购买了{}".format(mq.get()))
        sleep(2)
if __name__=="__main__":
#共享数据的容器
    mq = Queue()
#创建生产者线程
t1=Thread(target=produce)
#创建消费者线程
t2=Thread(target=consumer)
#开始工作
t1.start()
t2.start()

老师 关于生产者和消费者模式 我想问一下   两个线程 一个往队列里存放数据 另一个从队列里取数据 这个模式的意义就是在这两个线程中增加了一个队列 用来控制线程之间的平衡 可以这样理解吗

Python中的多线程是假线程，那为什么还有多线程这个概念，还有为什么有时候Python多线程就是比非多线程编程快?

from threading import Thread
from time import sleep, time


def func():
    global count
    for i in range(10000):
        count += 1


count = 0
start = time()
# for i in range(10):
#     t = Thread(target=func)
#     t.start()
# print(f"count = {count}")
for i in range(10):
    func()
print(f"count = {count}")
end = time() - start
print(end)

老师，注释内容和后续循环都能正确打印出结果，但是我发现打印出来的时间反而是多线程耗时更多一点，多次运行后发现要么是多线程运行耗时多，要么二者速度差不多。这样的话Python的多线程还有什么意义呢，没感觉到效率的提升啊。

from socket import *
s = socket(AF_INET, SOCK_DGRAM)
s.sendto("钟呢呢".encode("gb2312"), ("192.168.145.1", 8080))

请问同步执行和异步执行是什么？有什么区别？