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 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的方法 为什么没有打印线程的名字

#创建echo服务器，建立聊天室，建立双线程，能够实现全双工聊天

from socket import *
from threading import Thread

def send_message():
    while True:
        recvData=udpSock.recvfrom(1024)
        s=input("请输入发送内容：")
        udpSock.sendto(s.encode("gb2312"),recvData[1])
    udpSock.close()

def receive_messege():
    while True:
        recvData=udpSock.recvfrom(1024)
        print(recvData[0].decode("gb2312"))
    udpSock.close()


if __name__=="__main__":
    udpSock = socket(AF_INET, SOCK_DGRAM)
    udpSock.bind(("", 8585))
    t1=Thread(target=receive_messege)
    t2 = Thread(target=send_message)
    t1.start()
    t2.start()

老师，请问这样算是实现了全双工聊天吗？有点不明白怎样算是实现全双工聊天？

老师我这个t是外层的为什么可以这样调用，再一个就是编译器确实也提醒我没有被定义

为什么这里要传，而线程那里不用传，是有类的原因吗

# coding=utf-8
from threading import Thread
import time

def threading_test(name):
    i=50000000
    q=1
    for a in range(i):
        q = q+a
    print(q)
    print(f'任务{name}执行完')


t1= Thread(target=threading_test,args=('t1',))
t2= Thread(target=threading_test,args=('t2',))

s1=time.time()
t1.start()
t2.start()
s2=time.time()
print('多线程时间是',s2-s1)

老师你好， 我想测试一下多线程和普通方法运行的时间差异，所以就写了这段代码。这是运行截图

运行结果和我想的不一样。

理论上应该是先打印运行结果  在打印时间。

但是它是先打印时间  在打印运行结果。而且打印出时间后 隔了一段时间才打印出运行结果 所以这个时间应该也是不对的。

我不知道代码哪里问题了，在普通方式里是没问题的，运行出结果要8秒。推算的话多线程执行也要4秒。

麻烦老师帮我看一下哪里出问题了，应该是多线程的启动机制我没理解到位。

谢谢老师~

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

这里后面为什么又要用t2 是指什么吗 老师 

from multiprocessing import Process,current_process 
import os
from multiprocessing import Manager

def func1(name,m_dict,m_list):
    print("子进程ID{}获取了数据：{}".format(os.getpid(),m_list))
    print("子进程ID{}获取了数据：{}".format(os.getpid(),m_dict))
    m_list.append("姬昊余") #这里可以从子进程中往主进程里写
    m_dict["你好"]="吕倩倩"
if __name__=="__main__":
    print("主进程ID：{}".format(current_process().pid))
    #print("进程ID：{}".format(os.getpid()))
    with Manager() as mgr: #开启一个网络的端
        m_list=mgr.list() #创建一个列表
        m_dict=mgr.dict() #创建一个字典
        m_list.append("hello") #列表中添加数据
        p1=Process(target=func1,args=("p1",m_dict,m_list)) #也需要将容器传给子进程  
        p1.start()
        p1.join()
        print(m_dict)
        print(m_list)

老师 关于这个with 这里为什么要使用with 有点不理解 为什么不能之间创建共享数据对象

老师print（m_list）放在with manager里和外得出的结论是不一样的

放在with manager外的话代表的是什么，区别是什么

这是什么情况啊

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)
        print(f"Threading:{self.name} end")

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

老师，请问下这是怎么了呢，在VS code里面写的

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(maxsize=10)
    # 创建生产者线程
    t1 = Thread(target=producer)
    # 创建消费者线程
    t2 = Thread(target=consumer)
    t3 = Thread(target=consumer)
    # 开始工作
    t1.start()
    t2.start()
    t3.start()

老师，queue队列里的数据是不是 get（）之后就消失了

from threading import Thread,Event
from time import sleep
from random import randint
def door():
    while True:
        global state
        if even.is_set():
            print("门开着可以进门")
            sleep(1)
        else:
            state=0
            print("门关着请刷卡")
            even.wait()
        sleep(1)
        state+=1
        if state > 3:
            print("超过3秒,请刷卡")
            even.clear()
def person():
    num=1
    while True:
        global state
        
        if even.is_set():
            print(f"门开着,{num}号人进入")
        else: 
            print(f"门关着,{num}号人刷卡进入")
            even.set()
            # state=0
        num += 1
        sleep(randint(1,10))



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

老师，这里的主线程是什么？不太明白

"""
TFTP(Trivial File Transfer Protocol) --> 简单文本传输协议
使用这个协议，就可以实现简单文件的下载 --> TFPT端口号为69

实现TFTP下载器：
    下载：从服务器上将一个文件复制到本机上
    下载的过程：
        ~在本机创建一个空文件(与要下载的文件同名)
        ~向里面写数据(接受到一点就向空文件里写一点)
        ~关闭(接受完所有数据关闭文件)

[注意]：服务器的69端口只用来接受读写请求，ack包不要发送到69端口

"""
from socket import *
import struct

filename = 'dog.jpg'
server_ip = '192.168.1.17'
send_data = struct.pack('!H%dsb5sb' % len(filename), 1, filename.encode(), 0, 'octet'.encode(), 0)
s = socket(AF_INET, SOCK_DGRAM)
s.sendto(send_data, (server_ip, 69))
f = open(filename, 'ab')

while True:
    recv_data = s.recvfrom(1024)    # 接受数据
    caozuoma, ack_num = struct.unpack('！HH', recv_data[0][:4])    # 获取数据块编号
    rand_port = recv_data[1][1]   # 获取服务器的随机端口
    if int(caozuoma) == 5:
        print('文件不存在。。。')
        break
    print("操作码：%d, ACK:%d, 服务器随机端口：%d, 数据长度：%d"%(caozuoma, ack_num, rand_port, len(recv_data[1][1]))
    f.write(recv_data[0][4:])   # 将数据写入
    if len(recv_data[0]) < 516:
        break
    ack_data = struct.pack("!HH", 4, ack_num)
    s.sendto(ack_data, (server_ip, rand_port))     # 回复ACK确认包

嘛问题？