from threading import Thread, Lock

from time import sleep


def fun1():
    lost1.acquire()
    print("fun1已经拿到了刀，正在切菜")
    sleep(3)

    lost2.acquire()
    print('fun1要用锅做红烧肉，用完了要释放锅')

    lost2.release()#释放刀
    lost1.release()#释放锅
    print("做好了")

    print("做好了红绕肉完事了")


def fun2():
    lost2.acquire()
    print('fun2已经拿到了锅')
    lost1.acquire()
    print('fun2已经拿到了刀')
    lost2.release()
    lost1.release()
    print("做好了西兰花")


if __name__ == '__main__':
    lost1 = Lock  # 刀
    lost2 = Lock  # 锅

    t1 = Thread(target=fun1)
    t2 = Thread(target=fun2)

    t1.start()
    t2.start()
    
    
 #老师我为什么这里不是卡着 死循环，反而还报错了呢

from socket import *
from threading import Thread

s = socket(AF_INET, SOCK_DGRAM)
# 绑定IP端口
s.bind(("", 8798))


def func1():
    while True:
        recdate = s.recvfrom(2048)
        print('他说：',recdate[0].decode())

    # s.close()


def func2():
    while True:
        d = input('请输入：\n')
        senddate = s.sendto(d.encode(), ("192.168.0.105", 8768))
    # s.close()


if __name__ == '__main__':
    t1 = Thread(target=func1)
    t2 = Thread(target=func2)

    t1.start()
    t2.start()
    #s.close()

老师啊，这个聊天室大概是这样吗，这个close（）我不知道放在那里，放在方法里和放最后都会报错，

 在一个非套接字上尝试操作

老师啊，这个物理层和数据链路层之间的区别是啥，我感觉我有点搞混了

请问下我这个运行后为什么没结果测试greenlet切换

from time import time
from greenlet import greenlet
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()
    g1.switch()
    end=time()

    print(end-start)

老师，那 asyncio 最主要的作用也是开启协程吗？他就是将所有需要并发的方法打包进一个循环中，专门拿出一个CPU去监听这个循环里面，他还是需要去专门拿出一个CPU去监听，是不是可以把它理解成，在一个while true 监听下，将所有方法放在一个队列中，然后放在其中，一起监听所有方法

老师你说的单线程内可以实现并发的效果，意思，协程也是假并发，那我是不是能理解为他和GIL锁下的多线程的主要区别，就是少了个IO操作，并把所有方法放在一个线程里。

还有老师我不太明白，这个缺点里说阻塞，这个IO操作为啥会阻塞，图片里，不是把IO后的操作剥离出来，放在最后面了吗，还是说协程最后也是不执行IO操作的？

if __name__ == "__main__": print('主进程ID:{}'.format(current_process().pid)) with Manager() as mgr: m_list = mgr.list() m_dict = mgr.dict() m_list.append('Hello!!') p1 = Process(target=func,args=('p1',m_list,m_dict)) p1.start() p1.join() print(m_list) print(m_dict)老师为什么这里p1.start() p1.join() print(m_list) print(m_dict)这几句也要缩进到with 打开的Manager中

print('-'*30)myq = Queue(maxsize=3)myq.put(1)myq.put('a')myq.put('d')myq.put(4)print(myq.get())print(myq.get())print(myq.get())老师啊，这个设置了最大值，不应该就是前三个存进去了，最后一个4没存进去吗，那前三个不就在队里面了。为啥我打印的时候都没有

老师，这个队列是不是当他mq.get()后,这个数据就不存在队列中了，无法再次获取了，还是不太理解他的实际运用场景。。。

老师，这个EVENT事件的作用，相比原来的 旗子 是不是主要就多了个event.wait()，我能不能理解为他的作用是当evnet.claer（）后，将event.wait所在进程阻断使用，停止了这个进程？直到event.is_set（）重新成立后才能再次执行这个进程？

如果某个协程已经是dead状态，那么再切换进去将会切换到父协程，就会执行父协程。老师能给我讲讲这是个怎么回事吗？

老师,greenlet的main greenlet是什么

import asyncio#python 3.5 版本之前 需要写装饰器 @asyncio.coroutine 官网说3.10 将被移除。def func1(): for i in range(5): print('python是世界上最后的开发语言！！！') yield from asyncio.sleep(1) #释放cpu的使用权限 把yield from 改成await，3.7以后的版本不支持yield fromasync def func2(): for i in range(5): print('学编程去，尚学堂！！！！') asyncio.sleep(1)if __name__ == '__main__': g1 = func1() g2 = func2() #创建事件循环 loop = asyncio.get_event_loop() #监听事件循环 loop.run_until_complete(asyncio.gather(g1,g2))#asyncio.gather()将多个协程打包。 #关闭事件循环 loop.close()老师 我这个代码会报错。不知道哪里出现了问题， 把yield from 改成 await还是会报错。

视频中说协程无法利用多核资源。协程本身是个单线程，它不能同时将单个cpu的多个核用上。需要与进程配合才能运行在多cpu上。我的问题是，上面所说的意思是协程需要与进程配合才能运行在多cpu上还是协程需要与进程配合才能运行在一个cpu的多个核上？我的理解是一个python解释器开启一个进程，这个进程只有一个线程，然后我们在这个线程中运用协程来充分利用进程所在的这个核（cpu的一个核）。那么如果我们开启多进程，每个进程在不同的核中运行，这样就可以实现并行。不知道我的理解对不对。请老师指点！

老师，怎么用with语句加锁呢。文档中说“加锁还可以使用 with 效果一样”