老，为什么Process.__init__(slef)不可以放在self.name=name的下面

那里为什么可以不用加else

1、这里睡着了是什么意思，线程2为什么还会判断依然是100，可以继续取钱。

2、这里初始化些什么，不使用这段代码为什么不可以

from socket import *
#最简化的UDP服务端代码
from threading import Thread


def recv_data():
    while True:
        recv_data = s.recvfrom(1024)  # 1024表示本次接收的最大字节数
        recv_content = recv_data[0].decode('gbk')
        print(f"收到远程信息:{recv_content},from{recv_data[1]}")
        if recv_content == "88":
            print("结束聊天")
            break
def send_data():
    addr = ("127.0.0.1", 8888)
    while True:
        data = input("请输入:")
        s.sendto(data.encode("gbk"), addr)
        if data == "88":
            print("结束聊天")
            break


if __name__ == '__main__':
    s = socket(AF_INET, SOCK_DGRAM)  # 创建UDP的套接字
    s.bind(("127.0.0.1", 9999))  # 绑定端口
    t1 = Thread(target=recv_data())
    t2 = Thread(target=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()

老师，请问我运行的时候为啥没有请输入和收到远程信息这两个提示呢，我分开的程序就有

老师这里面run函数中的self.account.money可以被调用是因为下面使用类的组合了吧，就是draw1 = Drawing(80,a1).如果主程序中不用组合，那这里是不是就不可以调用money了？

老师这是为什么？

不理解为什么“服务端”与“客户端”这两个地方一样，我想“服务端”应为“serve_socket.sendto（msg.encode（”gbk“）），可这样运行会报错，请老师解答一下我的疑点

from socket import*
from threading import Thread


def recv_data():
    while True:
        recv_data = client_socket.recv(1024)
        recv_content = recv_data.decode('gbk')
        print(f"客户端说：{recv_content}，来自：{client_info}")
        if recv_data == 'end':
            print('结束')
            break


def send_data():
    while True:
        msg = input('>')
        client_socket.send(msg.encode('gbk'))
        if msg == 'end':
            print('结束')
            break


if __name__ == '__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)  # 建立TCP套接字
    server_socket.bind(('127.0.0.1', 8989))  # 本机监听8989端口
    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
s = socket(AF_INET, SOCK_DGRAM)
s.bind(("127.0.0.1", 8979))
def recv_data():
    while True:
        data = s.recvfrom(1024)
        print(f"收到远程信息：{data[0].decode('gbk')},来自：{data[1]}")
        if data[0].decode('gbk') == "88":
            print("聊天结束")
            break

def send_data():
    while True:
        data = input("请输入：")
        add = (("127.0.0.1", 8081))

        s.sendto(data.encode("gbk"), add)
        if data == "88":
            print("聊天结束")
            break
if __name__ == '__main__':
    t1=Thread(target=send_data())
    t2=Thread(target=recv_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()

为什么输入“88”，才接收到信息，如果输入其他的，则是一直显示请输入

#coding = utf-8
#未使用线程同步和互斥锁的情况
from threading import Thread
from time import sleep


class Account():
    def __init__(self,money,name):
        self.money = money
        self.name = name

#模拟题款操作
class Drawing(Thread):
    def __del__(self,drawingNum,account):
        Thread.__init__(self)
        self.drawingNum = drawingNum
        self.account = account
        self.expenseTotal = 0

    def run(self):
        if self.account.money < self.drawingNum:
            return
        sleep(1)    #判断玩可以取钱，则阻塞，就是为了测试发生冲突问题
        self.account.money -= self.drawingNum
        self.expenseTotal += self.drawingNum
        print(f'账号{self.account.name},余额是{self.account.money}')
        print(f"账号{self.account.name},总共取了{self.expenseTotal}")

if __name__ == '__main__':
    a1 = Account(100,'gaoqi')
    draw1 = Drawing(80, a1)  #定义一个取钱线程
    draw2 = Drawing(80, a1)  #定义一个取钱线程
    draw1.start()
    draw2.start()

老师，这个哪里出错了？

我想问一下调用event.wait（）阻滞了之后，会继续往下走！！，等sleep的时间结束之后，再执行完没有执行的

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

threading Thread
time sleep

Account:
    (moneyname):
        .money=money
        .name=name

Drawing(Thread):
    (drawingnumaccount):
        Thread.()
        .drawingnum=drawingnum
        .account=account
        .expenseTotal=():
        .account.money-.drawingnum<:
            sleep()
        .account.money -= .drawingnum
        .expenseTotal += .drawingnum
        (.account.name.account.money)
        (.account.name.expenseTotal)

__name__ == :
    a1=Account()
    draw1 = Drawing(a1)
    draw2 = Drawing(a1)
    draw1.start()
    draw2.start()

老师这个报错是什么原因呀？

# 单线程(s)         多线程(s)
# 5.16              3.04
# 5.08              3.20
# 5.01              3.06
# 4.92              3.10
# 4.99              3.26

# 4.91              3.11
# 5.05              3.13
# 5.21              3.08
# 4.91              3.19
# 4.94              3.08


from threading import Thread
from threading import Lock
from time import time


def getNumber1(name, num):
    for number in num[::]:
        print(f'{name}-{number}')
        num.remove(number)


def getNumber2(name, num):
    lock1.acquire()
    for number in num[::]:
        print(f'{name}-{number}')
        num.remove(number)
    lock1.release()


if __name__ == '__main__':
    start_time1 = time()
    num_list = [x for x in range(1, 100001)]

    lock1 = Lock()

    t1 = Thread(target=getNumber2, args=('t1', num_list))
    t2 = Thread(target=getNumber2, args=('t2', num_list))
    t3 = Thread(target=getNumber2, args=('t3', num_list))

    t1.start()
    t2.start()
    t3.start()

    t1.join()
    t2.join()
    t3.join()

    end_time1 = time()

    print(end_time1 - start_time1)


    # start_time2 = time()
    #
    # getNumber1('邓明宝', num_list)
    #
    # end_time2 = time()
    #
    # print(end_time2 - start_time2)

    # print(end_time1 - start_time1 - (end_time2 - start_time2))

    print("主线程-end")

这个多线程我加锁了，理论上已经相当于单线程了，为什么执行时间还会比单线程快很多

守护线程如果要设置的话，是不是所有的线程都要设置守护线程，我试了开启两个线程，只设置一个守护线程，结果好像两个在主线程结束后还都仍然运行