接着上一个问题，请问创建线程的优势是什么？

请问为什么要建线程？不用线程可以实现本节课的代码的效果吗?

为什么我的程序从上到下运行到了print("主线程，end"),主线程结束了,守护线程t1还在运行。

九:

还有这个，我设置一个守护线程t1，普通线程t2，运行结果里面，他们并没有抢先=线运行

这个地方为什么没有换行

老师，这里面没有用到父类的属性，为什么还需要初始化父类方法

这个为什么用targe和targs？

老师，这个怎么解决啊

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

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

#模拟提款的操作
class Drawing(Thread):
    def __init__(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.account.expenseTotal}")

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

z这个是什么原因？

#coding=utf-8
from threading import Thread
from time import sleep

def func1(name):
    print(f"线程{name},start")  # f 就是format
    for i in range(3):
        print(f"线程：{name},{i}:")
        sleep(1)
    print(f"线程{name},end")

if __name__=='__main__':
    print("主线程，start")
    #创建线程
    t1 = Thread(target=func1,args=("t1",))
    t2 = Thread(target=func1,args=("t2",))
    #启动线程
    t1.start()
    t2.start()
    print("主线程,end")

主线程，start

线程t1,start

线程：t1,0:

线程t2,start

线程：t2,0:

主线程,end

线程：t1,1:

线程：t2,1:

线程：t1,2:

线程：t2,2:

线程t1,end

线程t2,end

老师，有点不太明白这个代码运行的步骤 能帮我解释一下吗

from queue import Queue
from threading import Thread
from time import sleep

def producter():
    num = 1
    while True:
        if queue.qsize()<5:
            print(f"生产{num}号，手机")
            queue.put(f"手机：{num}号，")
            num+=1
        else:
            print("库存满了，请消费")
        sleep(1)


def consumer():
    while True:
        print(f"获取手机：{queue.get()}")
        sleep(1)

if __name__ == '__main__':
    queue=Queue()
    p = Thread(target=producter())
    p.start()
    c = Thread(target=consumer())
    c.start()
    c2 = Thread(target=consumer())
    c2.start()

消费线程没有启动，好奇怪

#coding=utf-8
from socket import *
from threading import Thread

def recv_data():
    while True:
        recv_data = client_socket.recv(1024).decode('gbk')
        print(f"客户端信息{recv_data}")

def send_data():
    while True:
        input_info = input("服务器发送消息：")
        input_info = client_socket.send(input_info.encode("gbk"))
        if input_info == "end":
            break

if __name__ == '__main__':
    chatroom_socket = socket(AF_INET,SOCK_STREAM)
    chatroom_socket.bind(("127.0.0.1",8850))
    chatroom_socket.listen()
    client_socket,socket_info=chatroom_socket.accept()
    print('服务器等待客户端连接')
    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()
    chatroom_socket.close()
    
    
#coding=utf-8
from socket import *
from threading import Thread

def recv_data():
    while True:
        recv_data = client_socket.recv(1024).decode('gbk')
        print(f"服务器信息：{recv_data}")

def send_data():
    while True:
        msg = input("客户端发送消息：")
        msg = 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",8850))
    print("客户端器连接服务器")
    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()

输入end无法结束

socket *
threading Thread

():
    :
        recv_data = client_socket.recv().decode()
        (recv_data)

():
    :
        input_info = ()
        input_info = client_socket.send(input_info.encode())
        input_info == :
            __name__ == :
    chatroom_socket = socket(AF_INETSOCK_STREAM)
    chatroom_socket.bind(())
    chatroom_socket.listen()
    client_socketsocket_info=chatroom_socket.accept()
    ()
    t1 = Thread(=recv_data)
    t2 = Thread(=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()
    chatroom_socket.close()

socket *
threading Thread

():
    :
        recv_data = client_socket.recv().decode()
        (recv_data)

():
    :
        msg = ()
        msg = client_socket.send(msg.encode())
        msg == :
            __name__ == :
    client_socket = socket(AF_INETSOCK_STREAM)
    client_socket.connect(())
    ()
    t1 = Thread(=recv_data)
    t2 = Thread(=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()

我打end 无法结束

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()

发不了也接不了消息

请问老师  是不是要同时把t1和t2都保护了才会守护主线程，不再继续下去

from threading import Thread
from time import sleep


class Account:
    def __init__(self,name,money):
        self.name=name
        self.money=money
#模拟提款操作
class Drawing(Thread):
    def __init__(self,drawingNum,account):
        Thread.__init__(self)
        self.drawingNum = drawingNum
        self.account = account
        self.expenseTotal = 0
    def run(self):
        if self.account.money - self.drawingNum < 0:
            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(120,"wanpeng")
    draw1=Drawing(80,a1)
    draw2=Drawing(80,a1)
    draw1.start()
    draw2.start()

老师这个问题是什么原因啊