老师，下面的callback回调函数的作用是什么？写与不写的区别在哪里？好像不影响进程的效率

p.apply_async(func=func1, args=(f"p{i+1}", ), callback=func2)

老师这个回调函数有具体介绍吗？不清楚。。

from time import sleep
from threading import Thread
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()

老师，这里调用an_jian方法后面的括号为什么不需要，还有什么时候调用需要加括号什么时候不需要加

#coding=UTF-8

from threading import Thread, Event
from time import sleep
from random import randint


def door():
    global state
    while True:
        if even.is_set():#如果even事件为真，则执行
            print('我是门：门开着，可以通行~')
            sleep(1)
        else:
            print('我是门：门关了~请刷卡！')
            state = 0#门已关闭，开门循环重置为0
            even.wait()#even事件为等待，进程暂停
        if state > 3:#state在3次循环后
            print('我是门：超过3 秒，门自动关门')
            even.clear() #even事件为假，所有even.wait()发挥作用，将进程暂停
        state +=1#循环一次，state+1，控制门开启时间
        sleep(1)#线程暂停1秒，控制循环时间
def person():
    global state
    n = 0#人员编号
    while True:
        if even.is_set():
            print('我是人：门开着：{}号进入'.format(n))
        else:
            even.set()#将even事件标记为真
            state = 0#开门循环重置为0
            print('我是人：门关着，{}号人刷卡进门'.format(n))
        n += 1
        sleep(randint(1, 10))#随机1-10米秒来一个人，模拟刷卡
if __name__ == '__main__':
    state = 0
    even = Event()
    even.set()
    d = Thread(target=door)
    d.start()
    p = Thread(target=person)
    p.start()

老师，在执行的时候应该先提示

我是门：门关了~请刷卡！

但是我的这个程序，直接就是开着门的，请帮忙看看问题在哪里，谢谢

老师从哪里可以看最多可以一次进行多少个线程啊？如果系统一共能开8个线程我开了4个，他们和开一个的效率一样吗？

老师从哪里可以看最多可以一次进行多少个线程啊？如果系统一共能开8个线程我开了4个，他们和开一个的效率一样吗？

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

嘛问题？

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("开始")
        print(f"射雕三部曲：{self.name}")
        sleep(5)
        print("结束")
for i in range(20):
    t1 = MyThread("神雕英雄传,神雕侠侣,倚天屠龙记")
    t1.setDaemon(True)
    t1.start()

print("主进程结束啦")

请问老师：上述代码，运行报下图错误是什么原因?

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(20):
        t = MyThread(f't{i+1}')
        t.start()
    print('主进程结束！')

老师，为什么我运行之后这里end顺序是乱的

请问老师：

        线程锁应该就是 threading.Lock() 吧？那互斥锁是否就是线程锁呢？还是互斥锁是递归锁呢？

def person():里面的代码没有count的数值，怎么进行判断

import asyncio
import functools

async def compute(x, y):
    print(f"compute:{x}+{y}...")
    await asyncio.sleep(1)
    return x+y

async def print_sum(x, y):
    # 创建task
    task = asyncio.create_task(compute(x, y))
    # task绑定回调函数
    task.add_done_callback(functools.partial(end, x, y))
    # 释放下CPU使用
    await asyncio.sleep(1)


def end(n, m, t):
    print(f'{n}+{m}={t.result}')

if __name__ == '__main__':
    # 创建事件循环
    loop = asyncio.get_event_loop()
    # 监听事件循环
    loop.run_until_complete(print_sum(1, 2))
    # 关闭事件循环
    loop.close()

老师，这结果好像没传过来。

老师，为什么line 12 是怎么回事

import struct
from socket import *

filename='易烊千玺'
server_ip='10.200.213.0'
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,'你好')

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[0])))
    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))

图片如下：

老师照着代码敲的，为什么会出错

from threading import Thread,Lock
from time import sleep


def fun1():
    lock1.acquire()
    print('fun1拿到菜刀')
    sleep(2)
    lock2.acquire()
    print('fun1拿到锅')

    lock2.release()
    print('fun1释放锅')
    lock1.release()
    print('fun1释放菜刀')

def fun2():
    lock2.acquire()
    print('fun2拿到锅')
    lock1.acquire()
    print('fun2拿到菜刀')
    lock1.release
    print('fun2释放菜刀')
    lock2.release()
    print('fun2释放锅')

if __name__ == '__main__':
    lock1=Lock
    lock2=Lock

    t1=Thread(target=fun1)
    t2=Thread(target=fun2)
    t1.start()
    t2.start()