import os
from multiprocessing import Pool
from time import sleep

def func1(name):
    print(f"进程id:{os.getpid()}-{name}")
    sleep(2)
    return name

def func2(args):
    print(args)

if __name__ == '__main__':
   # 方式一
    # 创建进程池对象
    pool = Pool(5)
    # callback=func2 -> 执行完func1后将返回值传给func2
    pool.apply_async(func=func1, args=("sxt1",), callback=func2)
    pool.apply_async(func=func1, args=("sxt2",), callback=func2)
    pool.apply_async(func=func1, args=("sxt3",), callback=func2)
    pool.apply_async(func=func1, args=("sxt4",))
    pool.apply_async(func=func1, args=("sxt5",))
    pool.apply_async(func=func1, args=("sxt6",))
    pool.apply_async(func=func1, args=("sxt7",))
    pool.apply_async(func=func1, args=("sxt8",))

    # 使用完进程池关上
    pool.close()
   # 等待所有子进程执行完，不然的话，主进程可能直接关掉了进程池，而子进程还没执行完
    pool.join()

老师，想问下为什么如果先让子进程执行完（即先运行pool.join()），再让主线程关闭进程池（再运行pool.close()），会报错，正常逻辑不就是这样吗

from threading import Thread
import threading
from time import time,sleep


def func(name):
    print(threading.currentThread())     # 查看当前进线程
    print(f'Threading:{name} start')
    sleep(3)
    print(f'Threading:{name} end')


if __name__ == '__main__':
    print(threading.currentThread())  # 查看当前进线程
    startTime = time()
    threadList = []
    for i in range(10):
        t = Thread(target=func, args=(f't{i+1}',))
        t.start()
        threadList.append(t)

    for t in threadList:
        t.join()     

    endTime = time()
    print(f'运行时间为：{endTime-startTime}')

问题：

在上一节课里老师讲到，t.join() 方法不能直接放在 t.start() 后面。但是在这节课里面，通过两个循环。第一个循环先生成了线程 t1-t10，生成了线程列表（threadList）后，通过第二个循环遍历线程列表，这个遍历不是在每个线程后加 t.join() 么，这样不就矛盾了吗？虽然结果没有问题，但迷糊了，麻烦老师解释一下。谢谢~

请问老师这里客户端发给服务器的第一个包里的ACK  = y+1是啥意思，为啥要在这里方式送一个ACK确认包？

老师，死锁这里，线程的创建，我看不懂？为什么是这样创建的？

import threading
class text1(threading.Thread)
    pass
t1 = text1()
t1.start()

老师，请问一下面这个是什么意思，没有理解

老师我这个代码输进去最后还是会显示end4

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__':
    thread_list = []
    for i in range(5):
        t = MyThread(f't{i+1}')
        #设置当前线程为守护线程
        t.setDaemon(True)
        t.start()
        
    print('主线程结束!!!')

--------------多进程一定快吗

老师，线程中的Queue()和进程中的Queue()，用法是差不多的吗？如果有区别，是什么区别？

我想问一下调用event.wait（）阻滞了之后，会继续往下走！！，等sleep的时间结束之后，再执行完没有执行的

from socket import *
'''test文件'''
# 创建对象
s = socket(AF_INET, SOCK_DGRAM) # ipv4 UDP 协议
s.bind(("", 8788))
s.sendto(b"data",("192.168.31.146",8585))
recvdata = s.recvfrom(1024)
print(recvdata[0].decode())

from socket import *
'''test1文件'''
udpSocket = socket(AF_INET, SOCK_DGRAM)
udpSocket.bind(("", 8585))
while True:
    recvdata = udpSocket.recvfrom(1024)
    print(recvdata[0].decode())
    data = input("请输入：")
    udpSocket.sendto(data.encode(), recvdata[1])
udpSocket.close()

老师我想问为什么我的程序先运行test1然后再运行test，不会和视频里的一样直接在pycharm里面返回，而是再调试助手里面返回了data，程序就卡着不动了

from threading import Thread
import time
def user_input():

    if thread2.is_alive() == False:
        enter = input("input something: ")
        print('alive')
    elif thread2.is_alive() == True :
        print("finish")


def timer():
    for i in range(30):
        time.sleep(1)

if __name__ == '__main__':
    thread1 = Thread(target = user_input)
    thread2 = Thread(target = timer)
    thread1.start()
    thread2.start()

老师请问一下如果我想在用户输入的时候同时进行一个30s的倒计时，如果30s倒计时结束用户还没有输入东西，直接结束线程print（“finish”）。如果用户输入了东西并且按了回车我就结束所有线程应该怎么做。谢谢老师！

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")

if __name__ == "__main__":     
    print(threading.currentThread())
    # 开始时间
    start = time()
    t1 = Thread(target=func1, args=('t1',))
    t2 = Thread(target=func1, args=('t2',))

    t1.start()
    t2.start()
    # func1('t1')
    # func1('t2')
    # 计算使用时间
    end = time() - start
    print(end)

运行结果：

老师，怎么看代码中，哪一块是主线程，哪一块是子线程

老师  第15行和第17行存在的作用是什么

多进程是各个进程交替切换执行吗？主进程和子进程有执行的先后顺序吗？

子进程之间有执行的先后顺序吗？

多个不同线程在执行时是在一个CPU中不断进行切换不同的线程进行执行的，多进程是每个进程在不同的CPU中进行执行的，不存在不断切换的问题，是这样吗