老师为什么我的代码加入了mq.qsize()<10:后，没起作用，还是一直生产和购买下去，哪里出错了吗

from threading import Thread

from queue import Queue

from time import sleep

def producer():

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=producer)

#创建消费者线程

t2=Thread(target=consumer)

t3=Thread(target=consumer)

#开始工作

t1.start()

t2.start()

t3.start()

#incoding=UTF-8
#线程的基本使用-------守护线程
from time import sleep,time
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)
        print(f"Threading:{self.name}end")


if __name__ == '__main__':
    # 创建线程
    for i in range(20):
        t = Thread(f't{i+1}')
        #设置当前进程为守护线程
        t.setDaemon(True)
        t.start()
    print("主进程结束了！！！")

请问这个报错的原因是什么呢？

老师我这个线程1和2怎么是同一时间运行完的，怎么没有执行完线程1睡上3秒后，再执行线程2.

from threading import Thread
from time import sleep

#线程的实现
#方法包装

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

#创建线程
t1=Thread(target=func1,args=('t1',))

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

#开始线程
t1.start()
t2.start()

老师你好，并发编程，不用vscode，用pycharm可以实现吗

觉得这节课老师讲得很好，讲课风格带动我了

#incoding=UTF-8
#方法包装-启动多线程
from threading import Thread
from time import time,sleep


def func1(name):
    print("Threading:{}start".format(name))
    sleep(3)
    print("Threading:{}end".format(name))

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

根据PDF敲的，这是什么情况呢？

#coding=utf-8

import threading
from socket import *
import time

def ReceiveData():
    r = socket(AF_INET,SOCK_DGRAM)
    r.bind(("192.168.0.104",7890))
    if a.acquire():
        while True:
            rec_data = r.recvfrom(1204)
            print(rec_data[0].decode())
            time.sleep(1)
            b.release()


def SendData():
    s = socket(AF_INET, SOCK_DGRAM)
    if b.acquire():
        while True:
            data = input("请输入：")
            s.sendto(data.encode(), ("192.168.0.104",7890))
            time.sleep(1)
            a.release()




if __name__ == "__main__":
    a = threading.Lock()
    b = threading.Lock()
    b.acquire()
    t1 = threading.Thread(target=ReceiveData)
    t2 = threading.Thread(target=SendData)
    t1.start()
    t2.start()

老师，我写的聊天室的程序，达不到效果，麻烦看一下哪里出错了

老师，我的网络接收器收到的消息为什么是十六进制的？

一、代码

#coding=utf-8

import threading
import time
from queue import Queue

class Pro(threading.Thread):
    def run(self):
        global q
        count=0
        while True:
            if q.qsize()<100:
                for i in range(10):
                    count = count+1
                    msg = "生成产品"+str(count)
                    q.put(msg)
                    print(msg)
            time.sleep(1)

class Con(threading.Thread):
    def run(self):
        global q
        while True:
            if q.qsize()>10:
                for i in range(3):
                    msg = self.name + "消费了" + q.get()
                    print(msg)
            time.sleep(1)


if __name__ == "__main__":
    q = Queue()
    for i in range(50):
        q.put("初始产品"+str(i))
        print("初始产品"+str(i))
    for i in range(2):
        p = Pro()
        p.start()
    for i in range(5):
        c = Con()
        c.start()

二、运行结果

生成产品1

生成产品2

生成产品3

生成产品4

生成产品5

生成产品6

生成产品7

生成产品8

生成产品9

生成产品10

Thread-3消费了初始产品0

Thread-3消费了初始产品1

Thread-3消费了初始产品2

Thread-4消费了初始产品3

Thread-4消费了初始产品4

Thread-4消费了初始产品5

Thread-5消费了初始产品6

Thread-5消费了初始产品7

Thread-5消费了初始产品8

Thread-6消费了初始产品9

Thread-6消费了初始产品10

Thread-6消费了初始产品11

Thread-7消费了初始产品12

Thread-7消费了初始产品13

Thread-7消费了初始产品14

Thread-4消费了初始产品15

Thread-4消费了初始产品16

Thread-4消费了初始产品17

生成产品11

生成产品12

生成产品13

生成产品14

生成产品15

生成产品16

Thread-3消费了初始产品18

Thread-3消费了初始产品19

Thread-3消费了初始产品20

生成产品11

生成产品12

生成产品13

生成产品14

生成产品17

生成产品18

生成产品19

生成产品20

生成产品15

生成产品16

生成产品17

Thread-7消费了初始产品21

Thread-6消费了初始产品22

Thread-6消费了初始产品23

Thread-6消费了初始产品24

Thread-7消费了初始产品25

生成产品18

生成产品19

Thread-7消费了初始产品26

Thread-5消费了初始产品27

Thread-5消费了初始产品28

Thread-5消费了初始产品29

生成产品20

Thread-4消费了初始产品30

Thread-4消费了初始产品31

Thread-4消费了初始产品32

Thread-3消费了初始产品33

Thread-3消费了初始产品34

Thread-3消费了初始产品35

Thread-5消费了初始产品36

Thread-5消费了初始产品37

Thread-5消费了初始产品38

Thread-6消费了初始产品39

Thread-6消费了初始产品40

Thread-6消费了初始产品41

生成产品21

生成产品22

生成产品23

生成产品24

生成产品25

生成产品26

生成产品27

生成产品28

生成产品21

生成产品22

生成产品23

生成产品24

生成产品25

生成产品26

生成产品27

Thread-7消费了初始产品42

Thread-7消费了初始产品43

Thread-7消费了初始产品44

生成产品29

生成产品30

三、问题

上述程序创造了2个产生数据的线程p1、p2，和五个输出数据的线程c1/2/3/4/5，产生数据的线程是一个循环，产生10个数据，消费数据的线程是输出3个线程，我知道线程之间是交替执行的，但是从结果中看出，一个线程的循环都没有结束都跳去了另一个线程里呢，而且还没有规律，请问老师这样是为什么？线程交替运行这么不可控，他存在的意思是啥，都不能用来计算？

一、代码

#coding=utf-8

import threading
import time
from queue import Queue

class Pro(threading.Thread):
    def run(self):
        global q
        count=0
        while True:
            if q.qsize()<1000:
                for i in range(100):
                    count = count+1
                    msg = "生成产品"+str(count)
                    q.put(msg)
                    print(msg)
            time.sleep(1)

class Con(threading.Thread):
    def run(self):
        global q
        while True:
            if q.qsize()>100:
                for i in range(3):
                    msg = self.name + "消费了" + q.get()
                    print(msg)
            time.sleep(1)


if __name__ == "__main__":
    q = Queue()
    for i in range(500):
        q.put("初始产品"+str(i))
    for i in range(2):
        p = Pro()
        p.start()
    for i in range(5):
        c = Con()
        c.start()

二、问题

1、

上述产生数据的两个进程是同时运行的还是一个运行完再运行下一个？

如其同时运行，当第一个进程已经往池中写入“生成产品1”，第二个进程还可以往里面写入“生成产品1”吗？

老师，上面这条语句的作用是什么，刚开始使锁处于False状态，怎样会变成True呢？

老师，线程之间是共享资源的，num公用同一个内存地址，为什么主线程等所有子线程跑完，num内存里的值不应该是2000000吗？

#coding=utf-8
import threading

num=0

def test1():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    mutex.release()

def test2():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    mutex.release()


mutex = threading.Lock()
p1 =threading.Thread(target=test1)
p2 =threading.Thread(target=test2)
p1.start()
p2.start()
print(num)

老师，为什么我的代码不能起到互斥锁的作用呢？

老师，前面视频里讲过，一个进程中的线程共享相同的内存单元，也就意味着上图中三个num都是同一个地址，为什么还会存在运算了num+1，但没有赋值，就切换到下一个线程的情况呢，运算和赋值不就是在一个地址上加1，不存在变量引用的情况，为什么还不是同时进行的？

老师，当一个程序的主进程启动一个 主线程，主线程再去启动其他主线程，主线程和其他子线程都是在一个CPU里面进行的吗?