想问一下，多线程并发在底层是怎么实现的，内存机制是什么

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)

用了互斥锁也还是会出错

运行不了怎么弄

from threading import Thread 
# 线程的实现
# 方法包装

# 创建普通方法
def func1(name):
    print(f"Threading:{name} start")

# 创建线程
t1 = Thread(target=func1,args=('t1',))
t2 = Thread(target=func1,args=('t2',))

# 开始线程
t1.start()
t2.start()

老师这样的报错一般是为啥啊？？？？？？？？？？

import struct  #数据转化
from socket import *

#存放要下载的文件
filename = input("请输入要下载的文件：")
#存放服务器的IP
server_ip = input("请输入服务器的IP地址：")
#按正确的格式转化要下载的文件
send_data = struct.pack("!H%dsb5sb"%len(filename),1,filename.encode(),0,"octet".encode(),0)
#创建socket对象
s = socket(AF_INET,SOCK_DGRAM)
#第一次发送到服务器，连接69端口
s.sendto(send_data,(server_ip,69))
#一追加模式打开一个新文件(重名的)
f = open(filename,"ab")

#循环开始下载任务
while True:
    #接收服务器传来的数据包
    recv_data = s.recvfrom(1024)
    #获取数据包的操作码和块编号
    caozuoma,ack_num = struct.unpack("!HH",recv_data[0][4])   #解析字节流，H可将转化为2字节,索引获取数据块编号
    #获取服务器随机端口号
    rand_port = recv_data[1][1]
    #判断一下是否可下载
    if int(caozuoma) == 5:
        print("该文件不存在")
        break
    print("操作码：%d,ACK:%d,服务器随机端口:%d,数据长度:%d"%(caozuoma,ack_num,rand_port,len(recv_data[0])))
    #将获取数据写入创建的f文件中去
    f.write(recv_data[0][4:])
    if len(recv_data[0]) < 516:
        break
    #获取返回的ACK确认包
    ack_data = struct.pack("!HH",4,ack_num)
    #回复ACK确认包
    s.sendto(ack_data,(server_ip,rand_port))

老师  就是我这个event对象会不会被其他线程的event.set启动  而且这个主线程是相当个进程吗

dest = ("<broadcast>",8080)

老师，我想请问一下你后面说的在局域网里面只要开放了8080端口都可以接收到数据，那这个不是一台计算机只能有一个端口嘛？这个怎么理解呢？

想问一下老师，为什么不是先执行完for循环后再打印最后一句“主线程结束了”

from threading import Thread
#测试线程的同时进行，导入sleep模块
from time import sleep
#创建方法
class MyThread(Thread):#继承Thread类
    def __init__(self,name):
        Thread.__init__(self) #因为重写了方法，所以手动调父类的构造函数
        self.name=name
    def run(self): #一定要用run（）方法
        print("threading:{} satrt".format(self.name))
        sleep(3)
        print("threading:{} end".format(self.name))

if __name__ == '__main__':
    threadlist=[]
    for i in range(10):
        t=MyThread(f"t{i+1}")
        t.start()
    print("主线程结束了！！")

老师，我想请问为什么文件名为中文名就会报错。

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

老师，

        我看到一些网站上说Python的基本数据类型是数字类型（int + float +[bool]（我目前基本没用，所以中括号））和字符串类型（我自己也是这样觉得的），但是有些资料上说序列也是Python的基本数据类型。

        如果说序列也是Python的基本数据类型，那么有序序列（元组和列表） + 无序序列（集合，字典）都是Python的基本数据类型了？

    另数据结构大概学到什么时候可以去看。我感觉自己写的都是拼凑型的小程序，看到大佬的才是666的。

发送方1：

from socket import *

s=socket(AF_INET,SOCK_DGRAM)
s.bind(('',8888))


s.sendto(b'sxt',('192.168.101.2',8090))

redata = s.recvfrom(1024)
print(redata[0].decode())

接受方：

from socket import *

udpSock=socket(AF_INET,SOCK_DGRAM)
udpSock.bind(('',8090))
while True:
    redata = udpSock.recvfrom(1024)
    udpSock.sendto(redata[0],redata[1])
udpSock.close()

vscode运行：

请问用vscode怎么才能运行，求解？

from socket import *
from threading import Thread


def recv_data():
    while True:
        recv_data = client_socket.recv(1024)  # 最大接受1024字节
        print(f'客户端说:{recv_data.decode("gbk")},来自:{client_info}')
        if recv_data == 'end':
            break
def send_data():
    while True:
        msg = input('>')
        client_socket.send(msg.encode('gbk'))

if __name__=='__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)  # 创建TCP套接字
    server_socket.bind(('127.0.0.1', 9999))  # 本机监听8899端口
    server_socket.listen(5)
    print('等待接受连接')
    client_socket, client_info = server_socket.accept()
    print('一个客户端建立连接成功')
    t1 = Thread(target=recv_data())
    t2 = Thread(target=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()
    server_socket.close()
    
    
    
    
    
from socket import *
from threading import Thread


def recv_data():
    while True:
        # 接收服务端数据
        recv_data = client_socket.recv(1024)  # 最大接收1024字节
        print(f'服务器端说:{recv_data.decode("gbk")}')
def send_data():
    while True:
        # 给服务端发消息
        msg = input('>')
        client_socket.send(msg.encode("gbk"))
        if msg == 'end':
            break
if __name__=='__main__':
    client_socket = socket(AF_INET, SOCK_STREAM)
    client_socket.connect(('127.0.0.1', 9999))
    t1 = Thread(target=recv_data())
    t2 = Thread(target=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()


    client_socket.close()

发不了也接不了消息

主进程创建子进程，那子进程可以创建子进程吗，还是子进程下吗没有了，就只有多个线程了呢？

怎么我的线程数是奇数，不是连续的数字吗，，，，，，

老师，我想请问为什么同样的结构，文件名为英文名就可以成功，文件名为中文名就会报错：

代码：

from socket import *
import struct

fileName = '焰灵姬.jpg'
adrr = '192.168.0.107'
cmb_buf = struct.pack('!H%dsb5sb'%len(fileName),1,fileName.encode('gbk'),0,'octet'.encode('gbk'),0)
s = socket(AF_INET,SOCK_DGRAM)
s.sendto(cmb_buf,(adrr,69))
f = open(fileName,'ab')
while True:
    recvdata = s.recvfrom(1024)
    caozuoma,ack_number = struct.unpack('!HH',recvdata[0][:4])
    rand_port = recvdata[1][1]
    if int(caozuoma) == 5:
        print('文件出错')
        break
    f.write(recvdata[0][4:])
    if len(recvdata[0]) < 516:
        print('文件传输完毕')
        break
    ack_data = struct.pack('!HH',4,ack_number)
    s.sendto(ack_data,(adrr,rand_port))