老师，想问下多线程模式和协程模式的实现效果有什么区别呢，假设现在有三个任务，多线程模式：因为同一时间只有一个线程使用cpu嘛，一个线程执行任务时阻塞了，另外不是立马会有另一个线程执行其他任务吗，而协程模式下：单线程执行任务，一个任务阻塞了也是立马去执行其他任务。对这两种模式的执行效果的区别不太清楚。

# # Python中的进程池相当于一个容器，里面存放指定数量的进程，当池中有空闲进程时，就可以拿来使用
# # 若没有空闲进程，则需要等待
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()
#

老师，程序运行结果如下，想问下，进程池中sxt1还没有执行func2打印sxt1，说明sxt1还在使用（不处于空闲状态），但是该进程为什么却被sxt6再次使用了呢

from threading import Thread
from time import sleep

def func1(name):
    for i in range(3):
        print(f"Thread {name}: {i}")
        sleep(3)

if __name__ == '__main__':
    print("主线程start...")
    # 创建线程
    t1 = Thread(target=func1, args=("t1",))
    t2 = Thread(target=func1, args=("t2",))
    # 执行线程
    t1.start()
    t2.start()
    # join()实现的是让主线程等待子线程结束后，再结束
    t1.join()
    # t2.join()
    print("主线程end...")

老师，想问下，为什么线程t2不适用join()方法，主线程还是等线程t1、t2都结束后再结束呢

老师，想问下，为什么这里不调用父类的初始化方法会报错呢

multiprocessing
time sleep


(conn1):
    sub_info = (multiprocessing.current_process().pidsub_info)
    sleep()
    conn1.send(sub_info)
    (conn1.recv())
    sleep()

(conn2):
    sub_info = (multiprocessing.current_process().pidsub_info)
    sleep()
    conn2.send(sub_info)
    (conn2.recv())
    sleep()


__name__ == :
    conn1,conn2 = multiprocessing.Pipe()
    process1 = multiprocessing.Process(=fun1,=(,))
    process2 = multiprocessing.Process(=fun2,=(,))
    process1.start()
    process2.start()

老师，我测试管道间通信的时候，有这个报错

老师这是什么原因请问我用自己的ip地址也报这个警报

老师我想问一下视频里快速导入是怎么实现的？

from multiprocessing import Process,current_process
from multiprocessing import Manager
def func(name,m_list,m_dict):
    m_dict['name'] = '尚学堂'
    m_list.append('你好')
if __name__ == '__main__':
    with Manager() as mgr:
        m_list = mgr.list()
        m_dict = mgr.dict()
        m_list.append('Hello')
        p1 = Process(target=func,args=('p1',m_list,m_dict))
        p1.start()
        p1.join()
        print(f'主进程：{m_list}')
        print(f'主进程：{m_dict}')

老师，第八九行可以理解为在manager管理器名为mgr的地方开辟空间叫为m_list和m_dict吗

from threading import Thread, Lock
from time import sleep
class Acount:
    def __init__(self,money,name):
        self.money = money
        self.name = name
class Drawing(Thread):
    def __init__(self,drawingNum,account):
        Thread.__init__(self)
        self.drawingNum = drawingNum
        self.account = account
        self.expenseTotal = 0
    def run(self):
        # lock1.acquire()
        if self.account.money-self.drawingNum<0:
            print("账户余额不足")
            return
        # sleep(1)
        self.account.money-=self.drawingNum
        self.expenseTotal+=self.drawingNum
        # lock1.release()
        print(f"账户：{self.account.name},余额是：{self.account.money}")
        print(f"账户：{self.account.name},总共取了：{self.expenseTotal}")
if __name__ == '__main__':
    a1 = Acount(100,"gaoqi")
    # lock1 = Lock()
    draw1 = Drawing(80,a1)
    draw2 = Drawing(80,a1)
    draw1.start()
    draw2.start()

老师，如果我不让它sleep是不是也可以呢

拿流水线比喻，创建线程就相当于雇一个员工，定义的方法就相当于员工所做的工作，可以这样理解吗

老师，这样的操作怎么实现

from socket import *
s = socket(AF_INET,SOCK_DGRAM)
s.bind(("",8888))
print("等待接受数据")
recv_data = s.recvfrom(1024)
print(f"收到远程信息：{recv_data[0].decode('gbk')},from {recv_data[1]}")
s.close()

老师，

s = socket(AF_INET,SOCK_DGRAM)

第二行这个代码是固定写法吗？后面两个参数啥意思

s.recvfrom(1024)

这个是表示客户输入的信息吗

print(f"收到远程信息：{recv_data[0].decode('gbk')},from {recv_data[1]}")

这里的recv_data[]里的0,1一定要写吗

t1=Thread()

老师你是怎么导入模块的

又出现新问题了

怎么没有请输入三个字呢？

from threading import Thread
from time import sleep


def func1(name):
   print(f"线程{name}, start")
   for i in range(2):
       print(f"线程:{name}，{i}")
       sleep(2)
   print(f"线程{name},end")


if __name__ == "__main__":
   print("主线程，start")
   t1 = Thread(target=func1, args=("t1",))
   t2 = Thread(target=func1, args=("t2",))
   t1.start()
   t2.start()
   print("主线程，end")

运行后：

主线程，start

线程t1, start

线程:t1，0

线程t2, start主线程，end

线程:t2，0

线程:t1，1

线程:t2，1

线程t1,end

线程t2,end

老师为什么我的代码运行后，”线程：t2,0”在”主线程，end”后面呐？