有点不明白程序运行的逻辑是怎么样的过程？

1，这里创建类对象

2，这里的功能把类对象传递给threadlocal,
是不是同时也是绑定了当前线程到threadlocal?

3，调用函数deal_student

4，从threadlocal获取当前线程的关联性？

5，是否对类对象的调用不用写？

6，变量stu是否会发生混乱？局部变量？
stu类对象保存在threadlocal中吗？

对于传递的问题总感觉云里雾里，希望老师能够解答疑惑。

关于字典中的内容不是很明白，为什么值是内存地址啊？

上面是老师的版本，下面是我修改的版本，

我想问的是：

1，在函数中调用其它函数，或者函数套嵌函数，那么这些函数就成为线程的私有数据了吗？

2，stu变量作为参数传递到下级函数中，也就是stu变量，不受线程影响了，在各自线程中独立存在？

3，stu=Student(name)是创建类对象，fun1(stu)是调用函数fun1,那么Student也被调用了吗？不明白这里是怎么回事啊？

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

from socket import *
a = socket(AF_INET,SOCK_DGRAM)     #创建套字节、为固定句式
address = ("192.168.10.40",8080)
date = input("输入发送内容：")
a.sendto(date.encode('GB2312'),address)
#接收数据
redate = a.recvfrom(1024) #括号内为最大字节数
print(redate[0].decode("GB2312"))
a.close()

为什么调试助手接收端还是没转化过来啊

import threading
num = 0
def test1():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    print(num)
    mutex.release()
def test2():
    global num
    if mutex.acquire():
        for i in range(100000):
            num += 1
    print(num)
    mutex.release()

mutex = threading.Lock()
p1 = threading.Thread(target=test1)
p1.start()
p2 = threading.Thread(target=test2)
p2.start()
print(num)

用了互斥锁也还是会出错

老师您好：下面的代码中 把for循环里面的i换成t 代码有颜色提示，但是也可以运行，怎么回事呢？

#测试多线程
import threading,time

def saySorry():
    print("子线程%s启动"%(threading.current_thread().name))
    time.sleep(1)
    print("亲爱的，我错了")

if __name__ == "__main__":
    print("主线程%s启动"%(threading.current_thread().name))
    for i in range(5):
        t = threading.Thread(target=saySorry) #Thread() 指定线程要执行的代码
        t.start()

为什么运行结束这个程序还没有结束啊，输出哪里显示还在运行中

老师执行结果的时候只有一行，一直在运行中，结束不了，这是什么原因啊

老师您好

下面代码放到python3中报错，怎么修改呢

#测试进程
from multiprocessing import Queue,Process
import time

def write(q):
    for value in ["a","b","c"]:
        print("开始写入：",value)
        q.put(value)
        time.sleep(1)
def read(q):
    while True:
        if not q.empty():
            print("读取到的是：",q.get())
            time.sleep(1)
        else:
            break

if __name__ == "__main__":
    q = Queue()
    pw = Process(target=write,args=(q,))
    pr = Process(target=read,args=(q,))
    pw.start()
    pw.join()
    pr.start()
    pr.join()
    print("接收完毕!")

这一小节没有看明白，不明白举3例子说明了啥 = = ！

因为我把前两个例子里的fun2()注释掉，只留fun1()感觉和TreadLocal结果一样。。。。

所以晕乎了

1、局部变量

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

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后面

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

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

#进程间通信---Queue
#通过Queue（队列Q）可以实现进程间的数据传递
#Q本身是一个消息队列

from multiprocessing import Process
from multiprocessing import Pool
from multiprocessing import Queue

def run1(q):
    q.put("消息")
    q.put("消息")

def run2(q):
    print(q.qsize())
    print(q.get())
    print(q.qsize())

if __name__ == "__main__":
    q = Queue(3)
    p1 = Process(target=run1,args=(q,))
    p2 = Process(target=run2,args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

multiprocessing
time

write(q):
    i :
        (,i)
        q.put(i)
read(q):
    time.sleep()
    i (q.qsize()):
        (,q.get())
__name__ == :
    q = multiprocessing.Manager().Queue()
    po = multiprocessing.Pool()
    po.apply_async(write,(q,))
    po.apply_async(read,(q,))
    po.close()
    po.join()

老师这个运行不出结果