老师第一个问题  关于这个事件 视频中老师举了两个例子 其实还是说明有两个线程 在调用一个方法的时候 可以通过事件event的一个状态来设置什么时候ti这个线程可以进入   什么时候t2这个线程可以进入 不管是车来了还是门开了 都是在说明这个问题 可以这样理解吗 

第二个问题 不管车来了还是门开了这两个例子里t1和t2线程 他们是并行还是串行  弄的有点混乱

这个老师讲的并发编程是真的听不懂啊 这应该怎么整  好多点都没有讲透彻 这部分有没有高琪老师讲的

from threading import Thread
from threading import Lock
#锁的目的 是为了保护数据的安全性
def func1(name):
    lock.acquire() #获取锁
    global count
    for i in range(100):
        count += 1
    lock.release() #释放锁 

if __name__ == "__main__":
    count=0
    t_list=[]
    lock=Lock()  #创建锁
    for i in range(10):
        t=Thread(target=func1,args=(f"t{i+1}",))
        t.start()
        t_list.append(t)
    for i in t_list:
        t.join()
    print(count)

老师  这个count循环是不是这样的   子线程每调用一次func1这个方法 里面的count就加100个1  因为是10的子线程所以最后打印count是1000  可以这样理解吗

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")
print(threading.currentThread())
#创建线程
t1=Thread(target=func1,args=("t1",))
t2=Thread(target=func1,args=("t2",))

#开始时间
start=time()
#开始线程
t1.start()
t2.start()
#结束时间
end=time()-start
print(end)

老师 这里这个时间0.00096是在 Threading：t1 start 后边才打印的   视频中老师不是说过 这个时间是在子线程开始之后就打印了  并没有将子线程的方法算到这个时间里边  这不是矛盾了吗

from threading import Thread
from time import sleep,time
#方法包装

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

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

#开始时间
start=time()
#开始线程
t1.start()
t2.start()
#结束时间
end=time()-start
print(end)

老师 这个时间就是指  从主线程创建两个子线程到子线程开始的时间  并没有等到子线程去调用方法（也就是子线程结束）  可以这样理解吗

from threading import Thread

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

    def run(self):
        print(f"Threading:{0} start".format(self.name)) #我用的format方法

#创建线程
t1=MyThread("t1")
t2=MyThread("t2")
#启动线程
t1.start()
t2.start()

老师 我用的是format的方法 为什么没有打印线程的名字

from threading import Thread
import time


class MyThread(Thread):

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

    def run(self):         # run 方法是规定好的， 不能改作其他名字
        print("Threading:{} start".format(self.name))
        time.sleep(3)

if __name__ == "__main__":
    t1 = MyThread('t1')
    t2 = MyThread('t2')
    t1.start()         # 开启线程，用start方法
    t2.start()

老师，初始化的时候为啥调用父类Thread的初始化方法，是因为重写了父类方法吗

想问一下老师，为什么不是先执行完for循环后再打印最后一句“主线程结束了”

from threading import Thread
#测试线程的同时进行，导入sleep模块
from time import sleep
#创建方法
class MyThread(Thread):#继承Thread类
    def __init__(self,name):
        Thread.__init__(self) #因为重写了方法，所以手动调父类的构造函数
        self.name=name
    def run(self): #一定要用run（）方法
        print("threading:{} satrt".format(self.name))
        sleep(3)
        print("threading:{} end".format(self.name))

if __name__ == '__main__':
    threadlist=[]
    for i in range(10):
        t=MyThread(f"t{i+1}")
        t.start()
    print("主线程结束了！！")

from socket import *


tcpSock = socket(AF_INET, SOCK_STREAM) #SOCK_STREAM 表示TCP
tcpSock.bind("", 7788) #默认使用7788端口做监听
tcpSock.listen(5) #最多只有5个同时监听
newSock, clientAddr = tcpSock.accept() #.accept()等待别人和自己创立链接


newSock.recv(1024)
newSock.send(b"xiexie")

newSock.close()

tcpSock.close()

老师请问这是什么情况

dest = ("<broadcast>",8080)

老师，我想请问一下你后面说的在局域网里面只要开放了8080端口都可以接收到数据，那这个不是一台计算机只能有一个端口嘛？这个怎么理解呢？

老师，运行后目录里面有文件了，但是不能加载图片，这是为什么呀？

from socket import *
import struct
filename = "dijia.jpg"
sever_ip = "192.168.1.4"
send_date = struct.pack("!H%dsb5sb" % len(filename),1,filename.encode(),0,"octet".encode(),0)
s = socket(AF_INET,SOCK_DGRAM)
s.sendto(send_date,(sever_ip,69))
f = open(filename,"ab")
#while True:
recv_date = s.recvfrom(1024)
print(recv_date)
    #caozuoma,acknum = struct.unpack()

老师，打印加载不出来，麻烦您帮我看看，还有老师我想请问一下就是从客户端发送下载请求到服务器，客户端是计算机嘛还是这个tftp呢？这个有点混；还有就是老师"!H%dsb5sb"这个里面为什么不写9s呢？因为后面不是还有一个1嘛？应该再写一个H啊，麻烦老师了

send_date = struct.pack("!H%dsb5sb" % len(filename),1,filename.encode(),0,"octet".encode(),0)

老师：课程中一直强调io不占用cpu，这个io具体怎么去理解，输入输出？例如是网络的收发？收发的速度肯定慢于cpu的执行速度，这样cpu就在收发的过程中，产生了间隙，可以让cpu去执行其他的任务吗？

from socket import *
import struct
 
if __name__ == '__main__':
    ftp_socket = socket(AF_INET, SOCK_DGRAM)
    send_data = struct.pack('!H8sb5sb', 1, b'123.jpeg', 0, b'octet', 0)
    ftp_ip = '192.168.1.7'
    ftp_socket.sendto(send_data, (ftp_ip,69))
    with open('/Users/zhangjiabing/Desktop/111/123.jpeg', "wb") as f:
        while True:
            receive_data = ftp_socket.recvfrom(1024)
            print(receive_data)
            operation_code,ack_num=struct.unpack('!HH',receive_data[0][:4])
            rand_port=receive_data[1][1]
            print(operation_code,ack_num)
            if operation_code==5:
                print('文件不存在')
                break
            else:
                f.write(receive_data[0][4:])
                print(receive_data[0],len(receive_data[0]))
                if len(receive_data[0])<516:
                    print('文件传输完成')
                    break
                ack_data=struct.pack('!HH',4,ack_num)
                ftp_socket.sendto(ack_data,(ftp_ip,rand_port))

老师，您好：

        这个作业，老师的点评是：

老师点评:

不要把代码都写在程序入口下面，失去了if __name__ == '__main__':存在的意义，注意规划代码结构

请教下老师，这个代码，如何规划才更合理。哪些应该放在

if __name__ == '__main__':

之外？谢谢

老师我这个设置了maxsize=10.为什么还往下生产呢

from threading import Thread
from time import time,sleep
from queue import Queue

#生产者
def producer():
    num = 1
    while True:
        # if mq.qsize()<10:
        print("生产{}号皮卡丘".format(num))
        mq.put(f"{num}号皮卡丘")
        num +=1
        sleep(1)

#消费者
def consumer():
    while True:
        print("购买{}".format(mq.get()))
        sleep(1)


if __name__ == '__main__':

    mq = Queue(maxsize=10)
    t1 = Thread(target=producer)
    t2 = Thread(target=consumer)

    t1.start()
    t2.start()