#进程池创建进程
#进程池是用来创建成百上千的多个进程

from multiprocessing import Pool
import random,time

def work(num):
    print(random.random()*num)
    time.sleep(3)

if __name__ == "__main__":
    po = Pool(3)    #定义一个进程池，最大进程数为3，默认大小为CPU核数
    for i in range(10):
        po.apply_async(work,(i,))   #apply_async选择要调用，每次循环会用空出来的子进程去调用目标
    po.close()    #进程池关闭之后不再接收新的请求，但是之前已经接收的请求会执行完
    po.join()     #等待po中所有子进程结束，必须放在close后面

#在多进程中：主进程一般用来等待，真正的任务都在子进程中执行

为什么按着代码敲完，运行的时候没有结果，程序也一直在运行中

self.account.money -= self.drawingNum
self.expenseTotal += self.drawingNum

这个例子中，为什么 account.money 的 -= 被执行了，而 expenseTotal 的 += 没有被执行？

python 队列，如果用多线程的话，设置队列的大小后，1、容易出现入队阻塞或者出队阻塞，请问如何解决？2、队列大小如何设定比较合理？（PS：因为我实际使用时如果队列大小过小就会发生阻塞，大了反而没事）

老师echo服务器这一章中发送信息的文件中IP地址是调试助手上的IP吗

一、程序

# 事件测试
from threading import Thread, Event
from time import sleep


def car():
    # global count
    num = 0
    while True:
        if event.is_set:
            print('车到站')
            sleep(1)
            # count += 1
            num += 1
            if num % 5 == 0:
                event.clear()
        else:
            print('车开走了')
            sleep(6)
            # count = 1
            event.set()


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


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

二、运行结果

三、疑问

老师请问，我这一开始运行结果为啥是‘车到站’，不应该是‘车开走了’了吗？谢谢老师解答

老师系统是先执行if语句还是自上而下执行呢

from threading import Thread
from threading import Lock
def func1(name):
    #获得锁
    #lock.acquire()
    #函数中使用全局变量
    global count
    for i in range(100000000):
        count+=1
    #释放锁
    #lock.release()
if __name__=="__main__":
    count=0
    t_list=[]
    #创建类对象
    lock=Lock()
    for i in range(10):
        t=Thread(target=func1,args=(f"t{i+1}",))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(count)

一、程序1

from socket import *

s = socket(AF_INET, SOCK_DGRAM)
s.bind(('', 8788))
s.sendto('abc'.encode(), ('192.168.1.6', 8585))
redata=s.recvfrom(1024)

print(redata[0])

程序2

from socket import *

udpsockt = socket(AF_INET, SOCK_DGRAM)
udpsockt.bind(('', 8585))
while True:
    redata=udpsockt.recvfrom(1024)
    # redata[0]是内容，redata[1]是地址
    udpsockt.sendto(redata[0], redata[1])
udpsockt.close

二、运行结果

老师请问，运行结果为啥是b‘abc’

我之前把'abc'.encode改写成b'abc',运行结果是b'abc',改回来之后还是b'abc'

老师：课程中一直强调io不占用cpu，这个io具体怎么去理解，输入输出？例如是网络的收发？收发的速度肯定慢于cpu的执行速度，这样cpu就在收发的过程中，产生了间隙，可以让cpu去执行其他的任务吗？

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()
    # 等待t1线程执行完再往下执行
    t1.join()
    # 等待t2线程执行完再往下执行
    t2.join()
    # func1('t1')
    # func1('t2')
    '''
    thread_list = []
    for i in range(100):
        t = Thread(target=func1,args=(f't{i+1}',))
        t.start()
        thread_list.append(t)
    for t in thread_list:
        t.join()
    # 结束时间
    end = time()-start
    print(end)

老师这里第二个for循环遍历列表里的线程，每遍历一个线程都join()，那不就是等这个线程结束才会遍历下一个线程，然后又join()又要等下一个线程结束才能接着遍历后面的，这就串行运行了啊，但是打印显示还是3秒多，麻烦老师解释一下我错在哪了

#coding=utf-8

from multiprocessing import Manager
from multiprocessing import Process

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

请问老师，args属性里面为什么m_list 一定要在m-dict前面？ 反过来就会报错

最后P1.join是什么意思？

老师，如果两个子进程都去修改manger传递的list的值，那主进程获取到的list值会不会出现脏数据呢

from socket import *
s = socket(AF_INET, SOCK_DGRAM)
s.sendto("钟呢呢".encode("gb2312"), ("192.168.145.1", 8080))

       老师，这条语句只能写在第17行吗

老师 执行第7行之后 就跳到func1这个函数里开始执行  执行到第4行的时候 卡住了 

然后跳到第8行 第8行接收了第3行的北京打印第0次数据   存储起来

接着开始执行第9行 第10行 

第11行 接着上次存储的 继续开始打印 北京打印第1次数据 

然后回到第9行 在开始新的一轮循环 

这个是这样理解吗 老师