老师，线程之间是共享资源的，num公用同一个内存地址，为什么主线程等所有子线程跑完，num内存里的值不应该是2000000吗？

#coding=utf-8
import threading

num=0

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

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


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

老师，为什么我的代码不能起到互斥锁的作用呢？

老师，前面视频里讲过，一个进程中的线程共享相同的内存单元，也就意味着上图中三个num都是同一个地址，为什么还会存在运算了num+1，但没有赋值，就切换到下一个线程的情况呢，运算和赋值不就是在一个地址上加1，不存在变量引用的情况，为什么还不是同时进行的？

老师，当一个程序的主进程启动一个 主线程，主线程再去启动其他主线程，主线程和其他子线程都是在一个CPU里面进行的吗?

老师，当多个线程进入可运行状态后，能否像多个进程那行多个线程同时运行，还是像上述 PPT里讲的那样，只能一个一个线程单独运行？

老师，自建类MyThread继承了Thread类，但其中name属性应该是Thread类的初始化函数中的参数，子类继承父类但不继承初始化函数，但上述程序中自建类为什么能访问name属性呢？

老师，您在之前解答中：

但我的程序，全局变量却发生了改变，这是为啥？

视频中，老师讲到上图程序，p1和p2是同时进行的，但前面视频中不是讲到，

麻烦老师讲解一下？上述程序是跑完p1再跑p2，还是有其他运行方式？

老师，还是不太明白为什么上述程序，先输出的process1，再输出“子程序运行中”，python程序不是按顺序执行的吗？

看了您之前的解释

那为什么，不加print（p.name）这条语句也应该先输出process-1啊？

还有下面的程序

#coding=utf-8

from multiprocessing import Process

def run():
    print("子进程运行中")
if __name__ == "__main__":
    print("父进程启动")
    p = Process(target=run)
    p.start()
    p.join()
    print(p.name)

输出结果却是：

麻烦老师解释一下，怎么Process-1又在后面执行了？

最后麻烦老师讲解一下，这一张讲解多线程的目的是什么，有点蒙，为什么从讲python程序调到了多线程课程？

# coding=utf-8

import threading
import time
from queue import Queue

class Pro(threading.Thread):
    def run(self):
        global q
        count = 0
        while True:
            if q.qsize()<1000:
                for i in range(100):
                    count += 1
                    msg = "生产"+str(count)
                    q.put(msg) # 往队列中添加新产品
                    print(msg)
            time.sleep(1)


class Con(threading.Thread):
    def run(self):
        global q
        while True:
            if q.qsize() > 100:
                for i in range(150):
                    msg = self.name+"消费"+q.get()
                    print(msg)
            time.sleep(1)


if __name__ == '__main__':
    q = Queue() # 创建队列，线程中能使用
    for i in range(500): # 放500个初始产品
        q.put("初始产品"+str(i))
    for i in range(2): # 两个生产者
        p = Pro()
        p.start()
    for i in range(5):  # 五个消费者
        c = Con()
        c.start()

老师，我给生产者设置的遍历区间是range(100)，给消费者设置的是range(150)，为什么消费者不能消耗完队列里面的产品，程序一会在执行。还有就是为什么要放入初始500个产品。

老师我想问一下，服务器每次能能发512B的数据，那么我们平时下载东西，比如说用迅雷下载电影，网速好的话，每秒都能达到十几M，为什么丝毫没感到慢呢，而且下载速度和带宽也有关系，麻烦解释一下！

# coding=utf-8
# 通过进程池创建进程
from multiprocessing import Pool
import random
import time

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


if __name__ == '__main__':
    po = Pool(3)
    print("进程池创建...")
    for i in range(10):
        po.apply_async(test, (i,))  # 非阻塞方式
    po.close()
    po.join()

老师，我想问下为什么我把函数命名为test就会报错

但定义为work就能运行

老师，为什么要给整个循环上锁，有问题的是 num+=1这一句代码，不能给这一句前后加锁和解锁吗？

如果是课堂讲的那种加锁，那跟程序先启动一个线程然后调用join方法等待它执行完毕，再启动另一个线程有什么区别？

好像没有区别，如果没有区别，那干嘛要加锁多次一举呢？

import struct,socket
filename="11.jpg"
serIp="192.168.31.242"
send_data=struct.pack("!H%dsb5sb"%len(filename),1,filename.encode(),0,b'octet',0)
udpSocket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udpSocket.sendto(send_data,(serIp,69))
f=open(filename,"ab")
while True:
    recv_data=udpSocket.recvfrom(1024)
    # print(recv_data)
    caozuoma,ack_num=struct.unpack("!HH",recv_data[0][:4])

    if int(caozuoma)==5:
        print("文件不存在")
        break
    print("操作码：%d,ACK:%d,服务器随机端口：%d，数据长度：%d"%(caozuoma,ack_num,recv_data[1][1],len(recv_data[0])))
    f.write(recv_data[0][4:])
    if len(recv_data)<516:
        break
    ack_data=struct.pack('!HH',4,ack_num)
    udpSocket.sendto(ack_data,(serIp,recv_data[1][1]))

老师这个是什么问题？

import threading,time
num = 0
def sum(x) :
    if mutex.acquire():
        for i in range(x):
            global num
            num += 1
    print(num)
    mutex.release()

def sum1(y) :
    if mutex.acquire():
        for i in range(y):
            global  num
            num +=1
    print(num)
    mutex.release()

if __name__ == "__main__" :
    mutex = threading.Lock()
    t = threading.Thread(target=sum,args=(1000000,))
    t1 = threading.Thread(target=sum1,args=(1000000,))
    t.start()
    t1.start()
    print(num)

80232

1000000

2000000

老师  这个是我这边的结果  为什么第一个print打印出来的不是1000000 而是80232