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

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

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

 为什么这句话还没打完，就插进来了？

正常的是这种

import threading
from threading import Thread
from time import sleep


class MyThread(Thread):
    def __init__(self, name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        self.printf()

    def printf(self):
        print(f"线程{self.name}-start", threading.current_thread())

        for i in range(0, 5):
            print(i)
            sleep(3)

        print(f'线程{self.name}-end')


if __name__ == '__main__':
    print('主线程-start', threading.current_thread())

    t1 = MyThread('t1')
    t2 = MyThread('t2')

    t1.daemon = True
    t2.daemon = True

    t1.start()
    t2.start()

    print('主线程-end')

def listen(self, __backlog: int = ...) -> None: ...

• backlog 可选参数代表套接字在拒绝新连接之前，操作系统可以挂起的最大连接数。backlog 参数一般设置为 5，若未设置，系统会为其自动设置一个合理的值。

• 
  

老师，我想了解listen有什么用，网上搜到了这段话，不懂

我以为listen是最大连接数，结果同时多个客户端向服务端发送请求建立连接时，前面的客户端发送一次数据就被强制断开连接，下一个客户端也只能发一次，直到最后一个客户端才可以正常收发

while True:
    client_socket, client_info = server_socket.accept()  # 阻塞，等待接收客户端信息
    # client_count += 1  # 当前连接的客户端数量+1
    # print(f'Server：new client，count：{client_count}')

    recv_data = client_socket.recv(1024)  # 最大接收1024
    print(f'client：{recv_data.decode("utf-8")}，来自{client_info[0]}, 端口号：{client_info[1]}')

    send_data = input("请输入需要TCP传送的信息体：").encode('utf-8')
    client_socket.send(send_data)  # 输入并编码后发送给客户端

    if recv_data == 'Bye' or send_data == 'Bye':
        break

我尝试将

client_socket, client_info = server_socket.accept()

移出循环体，只有第一个建立连接的客户端可以发，其它发了服务端收不到

老师，

TCP和UDP里面的最大接收数
client_socket.recv(1024)

这个最大接收数和接收缓冲区的最大容量有关系吗

# 服务端接收代码

from socket import *
from time import time


s = socket(AF_INET, SOCK_DGRAM)  # 创建UDP套接字

s.bind(('127.0.0.1', 1660))
while True:
    print('准备接收数据，接收中...')
    recv_data = s.recvfrom(1024)
    content = recv_data[0].decode("utf-8")
    print(f'消息接收成功，消息：{content}, 发送方IP：{recv_data[1][0]}， 发送方端口号：{recv_data[1][1]}')

    if content == 'Bye!':
        s.close()  # 关闭UDP套接字连接
        break
print("\n\n数据接收完毕！")

# 客户端发送代码

from socket import *
from random import randint
from time import sleep

content = ['Hello World!', '人生苦短，我用Python', 'PEP-8', 'UDP', 'TCP/IP', 'Bye!']

s = socket(AF_INET, SOCK_DGRAM)  # 创建UDP套接字

for data in content:
    # data = input("请输入需要发送的内容：")
    time = randint(2, 5)
    print(f'{time}s后开始发送消息...')
    sleep(time)
    s.sendto(data.encode('utf-8'), ('127.0.0.1', 1660))
    print(f'消息长度：{len(data)}, 消息已发送！')
else:
    print("\n\n数据发送完毕！")

是所有定义的类，里面定义的方法都得是run吗？感觉有点限制啊

from multiprocessing import Manager, Process


def fun(name,mg_list,mg_dic):
    mg_dic[name] = '尚学堂'
    mg_list.append('你好')

if __name__ == '__main__':
    #创建进程管理器
    with Manager() as mg:
        mg_list = mg.list()
        mg_dic = mg.dict()
        print(mg_list)
        print(mg_dic)
        p1 = Process(target=fun,args=('p1',mg_list,mg_dic))
        p1.start()
        # p1.join()#等p1进程结束后，主进程继续执行
        print('执行进程启动后~~')
        print(mg_list)
        print(mg_dic)

老师，为什么不写p1.join()会报系统找不到文件的错误呢

老师，我输入了一个正确的电脑ip，但是为什么显示地址无效，两个电脑是不同wifi下的，这个连接不上得原因是什么？可能是因为对方开了防火墙嘛?