老师运行这个代码要不要打开网络调试助手的呢？

老师搞不懂为什么视频里面是两个代码同时运行，都可以返回发送或者接收的信息，为什么我的不行的

老师，请问为什么我在11行这里加了even.wait()，运行的时候为什么不是只打印一次呢

from time import sleep
from threading import Thread
from threading import Event
from random import randint

def door():
    global state
    while True:
        if even.is_set():
            print('门开着，可以通行......')
            even.wait()
            # sleep(1)
        else:
            state = 0
            print('门关了，请刷卡！！！')
            even.wait()
        sleep(1)
        state += 1
        if state > 3:
            print('超过3秒，门自动关闭！！')
            even.clear()

def person():
    global state
    num = 1
    while True:
        if even.is_set():
            print(f'门开着呢，{num}号人进入......')
        else:
            print(f'门关着，{num}号人刷卡进入......')
            even.set()
            state = 0
        num += 1
        sleep(randint(1,10))

if __name__ == '__main__':
    state = 0
    even = Event()
    t1 = Thread(target=door)
    t2 = Thread(target=person)
    t1.start()
    t2.start()

老师，请问我这个是什么问题，把老师的复制过来就不报错，自己敲一遍就报错，下面的是我自己敲的

from threading import RLock

'''
Lock 锁 同步锁 互斥锁
RLock 递归锁
'''

def func1():
    lock.acquire()
    print('func1拿到锁')
    func2()
    lock.release()
    print('func1释放锁')

def func2():
    lock.acquire()
    print('func2拿到锁')
    lock.release()
    print('func2释放锁')

def func3():
    func1()
    func2()

if __name__ == '__main__':
    lock = RLock
    func3()

老师，额，可以问问这几个媒体已断开连接的，是什么啊？（后面要是有提到的话，您直接回复就好，我再自己看看）

老师，你好。有两个管道通信问题。

1. 管道通信内容只能使用一次吗？第6行也加入运行，程序卡在这里了。

2. 管道通信内容是否应该放在子进程开启（p1.start()）前定义？但课程中的是在子进程启动后定义的，按理子进程先启动，con2中还没内容应该报错的，但实际运行没报错。

from multiprocessing import Process,Pipe,current_process
import os

def func(name,con):
    print('当前进程{}，ID：{},内容是:{}'.format(name,current_process().pid,con.recv()))
    # print('当前进程{}，ID：{},内容是:{}'.format(name, os.getpid(), con.recv()))
    con.send('你好！')

if __name__=='__main__':
    print('主进程，ID：{}'.format(current_process().pid))
    print('主进程，ID：{}'.format(os.getpid()))
    con1,con2=Pipe()
    con1.send('Hello world!')
    p1.start()
    p1 = Process(target=func, args=('p1', con2))
    p1.join()
    print(con1.recv())

老师，那个，我想知道，用send或者next返回到yiled时，怎么确定返回的是哪一个yiled呢？当出现多个yiled时？

为啥我这个报错呀

from threading import Thread

#线程的实线
#方法包装
#创建普通方法
def func1(name):
    print(f"Threading:{name} start")
    
#创建线程
t1=Thread(target=func1,args=('t1',))
t2=Thread(target=func1,args=('t2',))
#开始线程
t1.start()
t2.start()
#func1('t1')
#func1('t2')

老师，你好。请教一个本节中全局变量使用问题。以下两段代码均使用全局变量,为什么第一段的count在person()函数中不需要重新声明全局变量就可以直接使用。第二段代码state需要在两个函数中都重新声明全局变量

代码一：

from time import sleep
from threading import Thread

def car():
    global count
    while True:
        if count % 5 !=0:
            print('车已到站，请上车')
            sleep(1)
        else:
            print('车已驶离，请耐心等待')
            sleep(6)
        count += 1


def person():
    while True:
        if count % 5 !=0:
            print('上车！！！')
            sleep(1)
        else:
            print('等待车')
            sleep(1)

if __name__=='__main__':
    count=1
    t1=Thread(target=car)
    t2=Thread(target=person)
    t1.start()
    t2.start()

代码二：

from time import sleep
from threading import Thread,Event
from random import randint
def door():
    global state
    while True:
        if event.is_set():
            print('门已开，可通行。。。。')
            sleep(1)
        else:
            state=0
            print('门已关，请刷卡！！！！')
            event.wait()
        sleep(1)
        state +=1
        if state>3:
            print('超过3秒，门自动关闭！！！！')
            event.clear()
def person():
    global state
    num=1
    while True:
        if event.is_set():
            print(f'门已开，{num}号进入')
        else:
            print(f'门已关，{num}号人刷卡进入')
            event.set()
        state=0
        num +=1
        sleep(randint(1,10))

if __name__=='__main__':
    state=0
    event=Event()
    t1=Thread(target=door)
    t2=Thread(target=person)
    t1.start()
    t2.start()

import asyncio
import functools
async def compute(x,y):
    print(f'compute:{x}+{y}....')
    await asyncio.sleep(1)
    return x+y


async def print_sum(x,y):
    # 创建task
    task = asyncio.create_task(compute(x,y))        #python3.7以上写法
    # task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y))  #python3.7以上写法
    # 释放下cpu的使用
    await asyncio.sleep(0)


def end(n,m,task):
    print(f'{n}+{m}={task.result()}')

if __name__ == "__main__":
    loop = asyncio.get_event_loop()

    loop.run_until_complete(print_sum(1,2))

    loop.close()

老师 这里task创建了一个任务计算x+y,下面的绑定回调函数是什么意思，为什么要绑定，以及绑定了之后怎么还要睡眠一秒，如果是0秒的话显示Task was destroyed but it is pending!我听不懂视频里的老师的表达，麻烦这里老师文字详细解释下

 #获得锁
 lock.acquire()
 #函数中使用全局变量
 global count
 for i in range(100000000):
     count+=1
 #释放锁
 lock.release()

老师讲的说这样获得锁释放锁能让他一个一个进行，不会出错，那这样，这就不是多线程了啊，多线程不是同时进行的吗？

t=Thread(target=func1,args=(f"t{i+1}",))

老师我不理解f't{i+1}',   里的f与，  这里为什么要有f和逗号？

from threading import Thread
from time import sleep,time
import threading
# 线程的实现
# 方法包装

# 创建普通方法
def func1(name):
    print(threading.currentThread())
    print(f"Threading:{name} start")
    sleep(3)
    print(f"Threading:{name} end")

if __name__ == "__main__":

    print(threading.currentThread())
    # 开始时间
    start = time()
    '''
    # 创建线程
    t1 = Thread(target=func1,args=('t1',))
    t2 = Thread(target=func1,args=('t2',))  

    # 开始线程
    t1.start()
    t2.start()
    # 等待t1线程执行完再往下执行
    t1.join()
    # 等待t2线程执行完再往下执行
    t2.join()
    # func1('t1')
    # func1('t2')
    '''
    thread_list = []
    for i in range(100):
        t = Thread(target=func1,args=(f't{i+1}',))
        t.start()
        thread_list.append(t)
    for t in thread_list:
        t.join()
    # 结束时间
    end = time()-start
    print(end)

老师这里第二个for循环遍历列表里的线程，每遍历一个线程都join()，那不就是等这个线程结束才会遍历下一个线程，然后又join()又要等下一个线程结束才能接着遍历后面的，这就串行运行了啊，但是打印显示还是3秒多，麻烦老师解释一下我错在哪了

from threading import Thread
from time import sleep

# 类实现-多线程
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print(f"Threading:{self.name} start")
        sleep(3)
if __name__ == "__main__":
    
    # 创建线程
    t1 = MyThread('t1')
    t2 = MyThread('t2')

    # 启动线程
    t1.start()
    t2.start()

老师我看了好多类的继承这样的写法，在子类的构造方法里都会调用父类的构造方法，这是固定写法吗？

如果是的话换成用super()去调用这样写可以吗？

from time import sleep
from threading import Thread
#类实现多线程
class MyThread(Thread):
def __init__(self,name):
Thread.__init__(self)
self.name=name

def run(self):
print(f"Threading:{self.name} start")
sleep(3)

#创建线程
t1=MyThread('t1')
t2=MyThread('t2')

#启动线程
t1.start
t2.start

我这里运行代码没有反应是怎么回事呢？