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

"""
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确认包

嘛问题？

老师你好，34行的wait（）语句他可以自己单独调用的吗，还是跟23行里面的sleep(6)有关联的，程序开始运行的时候调用了ti,t2线程打印 车开走了和等车 这2句话，一起等待了6秒之后才变为True，有点没搞懂

from threading import Thread
from threading import Event
from time import sleep
'''
1.Event()可以创建一个事件管理标志，该标志(event)默认为False。
2.event.wait(timeout=None)：调用该方法的线程会被阻塞，如果设置了,
  timeout 参数，超时后，线程会停止阻塞继续执行；
'''
def car():
    #global count
    num=0
    while True:
        if even.is_set(): #判断event的标值是否为True
            print('车已经到站，可以上车')
            sleep(1)
            #count=count+1
            num=num+1
            if num % 5  == 0:
                even.clear() #将event设置为False

        else:
            print('车开走了...')
            sleep(6)
            #count=1
            even.set()  #将event设置为True

def person():
    while True:
        if even.is_set():
            print('上车')
            sleep(1)
        else:
            print('等车')
            even.wait()
            #sleep(1)

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

# Tftp简单传输文件协议，默认端口号69（该端口仅用于读写请求）

import struct   # 按一定格式组织数据
from socket import *

# 传输格式"1PICTURE.jpg0octet0"---"操作码+文件名+分割0+模式+结尾0"--(1,b"PICTURE.jpg",0,b"octet",0)
# 按格式组织数据
'''实现TFTP下载器：
    下载：从服务器上将一个文件复制到本机上
    下载的过程：
        ~在本机创建一个空文件(与要下载的文件同名)
        ~向里面写数据(接受到一点就向空文件里写一点)
        ~关闭(接受完所有数据关闭文件'''

filename="PICTURE.jpg"
sever_ip="192.168.10.107"
send_data=struct.pack("!H%dsb5sb"% len(filename),1,filename.encode(),0,"octet".encode(),0)  # !表示按网络传输数据要求组织数据；H对应1占用2字节；b代表0占用1字节
udpSocket=socket(AF_INET,SOCK_DGRAM)
udpSocket.sendto(send_data,(sever_ip,69))
f=open(filename,"ab")    # 创建空文件--文件名与需要下载的名称一致

while True:
    # udp的发送接收内容--元组--（消息内容,（ip,端口号））
    rec_data=udpSocket.recvfrom(1024)   # 数据接收,前两个字节为操作码，后两字节块编号，后512字节为写入内筒
    operation_code,ack_num=struct.unpack('!HH',rec_data[0][:4])  # 操作码operation_code，数据块编号ack_num，struct.unpack解析消息内容
    # rec_data[0][:4]--0代表元组第一个元素，:4代表元组前4个元素
    rand_port=rec_data[1][1]   # 获取服务器的随机端口
    if int(operation_code)==5:
        print("文件不存在")
        break
    print("操作码：%d,ACK：%d,服务器随机端口：%d,接收的数据长度：%d",operation_code,ack_num,rand_port,len(rec_data))
    f.write(rec_data[0][4:])  # 将消息内容（516字节），由于前4个字节为操作码和数据块编号，所以后514字节进行数据写入
    if len(rec_data[0])<516:  # 小于516，说明已经传输到最后一个数据包
        break
    ack_data=struct.pack("!HH",4,ack_num)   # 需要用于确定的ack数据包
    udpSocket.sendto(ack_data, (sever_ip, rand_port))  # 给对方服务器回复ack确认包

为什么这个一直保持运行状态，没有结果啊？

from multiprocessing import Pool,Manager
import time
import os
def copy_information(source_folder,dest_folder,file):
    start_time = time.time()
    try:
        fr = open('H:\pythonShangxuetang/'+source_folder+'/'+file,'r',encoding='utf-8')
        fw = open('./'+dest_folder+'/'+file,'w',encoding='utf-8')
        try:

            print('文件%s开始复制'%file)
            fr_content = fr.read()
            fw.write(fr_content)
            end_time = time.time()
            print('文件%s复制所用时间：%d'%(file,end_time-start_time))
        except Exception as e:
            print('文件读写错误原因是：%s'%e.args)
    except Exception as d:
        pass
    finally:
        fr.close()
        fw.close()
def main():
    count =0
    #定位具体所需要复制的文件夹
    folder_name = input('请输入需要复制的文件夹：')
    #创建新的文件夹名称
    newFolderName = folder_name +'复件'
    os.mkdir(folder_name+'复件')
    #获取文件夹中的所有文本
    qu = Manager().Queue()   #创建queue，进程间通信
    file_names = os.listdir('H:\pythonShangxuetang/'+folder_name)
    qu.put(file_names)
    #创建进程池进行多任务配合
    p1 = Pool(5)
    # for i in file_names:
    while True:
        if not qu.empty():
            p1.apply_async(copy_information,args=(folder_name,newFolderName,qu.get()))
            count +=1
        else:
            break
    print('文件复制start')
    p1.close()
    p1.join()
    print('一共复制%d个文件'%count)
    print('文件复制end')

if __name__=='__main__':
    main()

问题：复制不成功，逻辑思维manager.queue让进程间通信，将目录文件夹下的文件信息保存到queue中。

一、程序

'''
线程的创建与使用
线程的创建方法二：
类包装
'''
# 调用线程模块
from threading import Thread


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

    def run(self):
        print('threading{0} start',format(self.name))


# 创建线程
t1 = Mythread("a")
t2 = Mythread('b')

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

二、运行结果

三、疑问

老师请问，问题如下图，谢谢老师解答！

老师tftp不也是服务器收不到数据的时候，客户端在发送数据，然后有确认包么，那个tftp是udp协议的么

from threading import Thread
from time import sleep
from threading import BoundedSemaphore
def an_jian(num):
    lock.acquire()
    print(f"第{num}个人完成安检")
    sleep(2)
    lock.release()


if __name__ == '__main__':
    lock = BoundedSemaphore(3)
    for i in range(10):
        t = Thread(target=an_jian, args=(f"{i+1}",))
        t.start()

F:\Python\pythonProject\multi-processes\venv\Scripts\python.exe F:/Python/pythonProject/multi-processes/mp8-信号量.py

第1个人完成安检

第2个人完成安检

第3个人完成安检

第5个人完成安检第6个人完成安检第4个人完成安检

第7个人完成安检

第9个人完成安检

第8个人完成安检

第10个人完成安检

Process finished with exit code 0

请问一下老师, 为什么结果会不按着顺序来的? 是有什么bug吗

你这里的for循环调用函数不就相当于依次开启线程吗,那不久成了顺序执行调用函数吗.

并行的意义就失去了呀

count = i ():
    i ():
        count += (count)

实现的结果就相当与这段程序嘛,

没有体现多线程啊

多线程的话应该是

每个线程都运行 fun1

输出结果 是 三个 1000啊

优点在于 同时执行了三次 函数 fun1

这样嵌套和执行上面的代码效率是一样的啊

对项目没有实际提升啊老师

from multiprocessing import Manager, Process


def fun(name,mg_list,mg_dic):
    mg_dic[name] = '尚学堂'
    mg_list.append('你好')

if __name__ == '__main__':
    #创建进程管理器
    with Manager() as mg:
        mg_list = mg.list()
        mg_dic = mg.dict()
        print(mg_list)
        print(mg_dic)
        p1 = Process(target=fun,args=('p1',mg_list,mg_dic))
        p1.start()
        # p1.join()#等p1进程结束后，主进程继续执行
        print('执行进程启动后~~')
        print(mg_list)
        print(mg_dic)

老师，为什么不写p1.join()会报系统找不到文件的错误呢

老师这里没用有else 或者 elif 为什么就能判断相反的条件呢

老师，我想请问一下是需要下载虚拟机是吗？输入查看不了Vmvare得ip

Tftpd32是构建一个服务器的作用吗

改成本机ip也没事吧

这个问题怎么改啊