老师，请问在这个过程中

为什么没有出现，（因为t.join依靠for循环来依次执行，对于任何一个t.join,主线程都需要等待这个子线程结束，以致for循环停滞）的现象

或者

这里从t1.join()到t2.join(),需要主线程的运行吗？否则就到t1停一下，等t1执行完，再到t2停一下。。

老师，执行此代码的时候，next语句开始执行consumer方法，此时g生成器中应该还没有给n传递值，此时

print(f"生产了第{n}个产品")

这个语句是否执行了呢？为什么打印出来生产了第0个产品？

from time import sleep
from threading import Thread
from threading import Event

def car():
    global count
    num=0
    while True:
        #if even.is_set():
        if count%5 !=0:
            print("车已到站，可以上车!!!")
            sleep(1)
            count += 1
            num+=1
            #if num %5 ==0:
                #even.clear()
        else:
            print("车开走了...")
            sleep(6)
            count=1
            #even.set()
def person():

    while True:
        if count %5 !=0:
        #if even.is_set():
            print("上车!!!")
            sleep(1)
        else:
            print("等待车！！！")
            #even.wait()

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

老师，car方法中将count声明为全局变量并且进行新的赋值。而person方法中没有进行声明。线程1调用car方法修改count值后，是不是线程2在调用person方法的时候，就获取到了新的count值？所以不需要声明？如果线程2的运行速度比线程1快，会不会获取到错误的值呢？运行结果如下

from time import sleep
from threading import Thread
from threading import Event

def car():
    global count
    num=0
    while True:
        if even.is_set():
            print("车已到站，可以上车!!!")
            sleep(1)
            #count += 1
            num+=1
            if num %5 ==0:
                even.clear()
        else:
            print("车开走了...")
            sleep(6)
            #count=1
            even.set()
def person():

    while True:
        #if count %5 !=0:
        if even.is_set():
            print("上车!!!")
            sleep(1)
        else:
            print("等待车！！！")
            even.wait()

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

老师，为什么会出现这种情况，是不是person的线程运行的速度有时候比car的线程快导致的？

# 类包装-启动多线程
from threading import Thread
from time import sleep, time


class MyThread(Thread):
    def __init__(self, name):
        Thread.__init__(self)
        self.name = name

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


if __name__ == '__main__':
    # 开始时间
    start = time()
    # 创建线程列表
    t_list = []
    # 循环创建线程
    for i in range(10):
        t = MyThread(f't{i}')
        t.start()
        t_list.append(t)
        # 等待线程结束
    for t in t_list:
        t.join()
    # 计算使用时间
    end = time() - start
    print(end)

 请问为什么    Threading 结束的内容  格式 不和开始 的格式 一样？

C:\Users\Administrator\AppData\Local\Programs\Python\Python38\python.exe "H:/python DM/并发编程/02_多线程测试_类方法启动.py"

Threading:t0 start

Threading:t1 start

Threading:t2 start

Threading:t3 start

Threading:t4 start

Threading:t5 start

Threading:t6 start

Threading:t7 start

Threading:t8 start

Threading:t9 start

Threading:t1 end 

Threading:t0 end 

Threading:t5 end 

Threading:t4 end Threading:t3 end Threading:t2 end 

Threading:t9 end 

Threading:t8 end Threading:t7 end Threading:t6 end 

3.003864288330078

Process finished with exit code 0

from threading import Thread,Event
from time import sleep


def car():
    global count
    while True:
        if count % 5 != 0:
            print('车到站')
            sleep(1)
            count += 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()

问题一：出现了以下情况提示一次车到站却有两个上车

问题二：

老师，视频中提到的“必须使用同一把锁” 这个使用同一把锁是如何实现的？

老师这个RLock是不是就是系统自动帮你调节，避免出现死锁的情况，也就是说当我只创建了一个锁的对象时，而这个锁恰好又被多个对象使用，导致锁不够用成了死结，而RLock就是调节当锁不够用的时候避免出现死结的方法，还可以让线程继续运行下去。

请问本节课的代码，为什么输出的count应该是10的倍数？

function中运行后不应该是1+2+..+10000 吗?

然后20行：

for i in range(10)：

是表示function中count的结果继续加吗？谢谢

在使用for循环中，

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

这里在args后加了f

但是在没有for循环时，

t1= Thread(target=func1, args=('t1',))

这里不加f，请问是为什么呢？

老师，我想问一下在这个生产者消费者的例子中，如何将线程的名字赋予到其执行的函数当中，就是两个消费者线程一个是张三，一个是李四，在终端进行购买的时候如何显示某某购买了第几只加菲猫，这样下面的代码如何修改

#coding=utf-8
from threading import Thread
from queue import Queue
from time import sleep
def producter():
    num=1
    while True:
        mq.put('{}号加菲猫'.format(num))
        print('{}生产出了第{}只加菲猫！'.format(t1.name,num))
        num+=1
        print(t1.name+'目前还能生产'+str(mq.maxsize-mq.qsize())+'只')
        sleep(1)

def consumer():
    global count
    while True:
        print(f'第{count}次购买：消费者购买了{mq.get()}')
        sleep(3)
        count+=1

if __name__=='__main__':
    count=1
    mq=Queue(maxsize=5)
    t1=Thread(target=producter,name='宠物店')
    t2=Thread(target=consumer,name='张三')
    t3=Thread(target=consumer,name='李四')
    t1.start()
    t2.start()
    t3.start()

老师好，这里说使用的是vs code，请问这一章用pycharm是否都一样？谢谢

老师，为什么这里写到了一起 而不是跟上面一样分行输出

老师这里是只有定义这个run方法这个名才能在这个类里被自动调用执行么