用锁是不是就和单线程一样，感觉都没有并行

from socket import *
s= socket(AF_INET,SOCK_DGRAM)
addr = ("192.168.2.120",8083)
a = input("请输入:")
s.sendto(a.encode("gb2312"),addr)
redata = s.recv(2048)
print(redata[0].decode("gb2312"))
s.close()

我在调试助手发送消息后,提示这个报错:

Traceback (most recent call last):

  File "E:/project/multiprocessing/testsocket.py", line 7, in <module>

    print(redata[0].decode("gb2312"))

AttributeError: 'int' object has no attribute 'decode'

老师，视频中有些内容好像接不上，一些东西，也都没有

threading.current_thread.getName() 这个是线程的名字吗？

老师std为什么打印出来是这样的？

"""协程的基本使用-asyncio的task的使用"""
import functools
import asyncio
async def compute(x,y):
    print(f"compute:{x}+{y}....")
    await asyncio.sleep(1)
    return x+y

async def print_sum(x,y):
    #创建task
    task = asyncio.create_task(compute(x,y))
    #task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y))
    #释放一下cpu的使用
    await asyncio.sleep(1)

def end(n,m,t):
    print(f"{n}+{m}={t.result}")

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_sum(2,3))
    loop.close()

这个是什么情况啊老师？？

求解

为什么1还没出来2就进去了

老师，我这个图片怎么下载不了，我换过图片和格式了，还是这样子。

import struct
from socket import *
filename = 'xxm.jpg'
server_ip = '192.168.0.110'
send_data = struct.pack('!H%dsb5sb' % len(filename), 1, filename.encode(), 0, 'octet'.encode(), 0)
s = socket(AF_INET, SOCK_DGRAM)
s.sendto(send_data, (server_ip, 69))  # 第一次发送, 连接服务器69端口
f = open(filename, 'ab')  #a:以追加模式打开（必要时可以创建）append;b:表示二进制
while True:
    recv_data = s.recvfrom(1024)  # 接收数据
    caozuoma, ack_num = struct.unpack('!HH', recv_data[0][:4])  # 获取数据块编号
    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.write(recv_data[0][4:])#将数据写入
    if len(recv_data[0]) < 516:
        break
    ack_data = struct.pack("!HH", 4, ack_num)
    s.sendto(ack_data, (server_ip, rand_port))  # 回复ACK确认包

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

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

import asyncio
import functools

async def compute(x,y):
    print(f'compute:{x}+{y}.....')
    await asyncio.sleep(1)
    return x+y

async def print_sum(x,y):
    # 创建task
    task = asyncio.create_task(compute(x,y)) # python3.7以上写法
    # task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y)) # python3.7以上写法
    # 释放下cpu的使用
    await asyncio.sleep(1)

def end(n,m,t):
    print(f'{n}+{m}={t.result()}') # t对应传的task

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_sum(1,2))
    loop.close()

老师，我有以下几个问题，麻烦老师帮忙解答一下，谢谢！

1. 我不太清楚这块代码执行的顺序，然后debug发现结果跟直接运行的结果不一样，麻烦老师解释一下这里代码是以怎样的顺序执行的。

2. 为什么在print_sum()里面不加await asyncio.sleep(1)会报错，加了就不会报错。

3. compute()里面执行了await asyncio sleep(1)之后，不是会释放cpu吗？又靠什么代码切换到compute()执行下一行代码return x+y呢？

4. compute()的结果是怎么传给task的？

能否把这一章节的代码内容按照课程内容编号重新整理一下呢？

这一章视频内演示代码的文件题目和给的文件都应对不上。还分了不同文件夹，非常难找。

能否按照之前章节，把每次课对应的代码编个号，方便学习。谢谢

如果多个线程都已经调用了start方法，那么之后他们的执行顺序就不再确定了，有操作系统决定，在同一个CPU中不断切换，交替执行？但是如果有的线程还没有调用start方法（比如由于sleep导致），那么他们的执行顺序就是确定的，调用了start方法的线程先执行。可以这样理解吗？

#coding=utf-8

from socket import *
from threading import Thread


def recv_data():
    while True:
        recv_data = client_scoket.recv(1024)
        print(f"收到信息:{recv_data.decode('gbk')},来自:{client_info}")
        if recv_data == "end":
            break


def send_data():
    while True:
        msg = input(">")
        client_scoket.send(msg.encode("gbk"))

if __name__ == "__main__":
    server_socket = socket(AF_INET, SOCK_DGRAM)  # 建立TCP套接字
    server_socket.bind("127.0.0.1", 8899)  # 本机监听端口8899
    server_socket.listen(5)
    print("等待接收")
    client_scoket,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_scoket.close()
    server_socket.close()

主进程中的主线程和主进程中的子线程在同一个CPU中交替不断切换执行，可以这样理解吗

#coding=UTF-8

from threading import Thread, Event
from time import sleep
from random import randint


def door():
    global state
    while True:
        if even.is_set():#如果even事件为真，则执行
            print('我是门：门开着，可以通行~')
            sleep(1)
        else:
            print('我是门：门关了~请刷卡！')
            state = 0#门已关闭，开门循环重置为0
            even.wait()#even事件为等待，进程暂停
        if state > 3:#state在3次循环后
            print('我是门：超过3 秒，门自动关门')
            even.clear() #even事件为假，所有even.wait()发挥作用，将进程暂停
        state +=1#循环一次，state+1，控制门开启时间
        sleep(1)#线程暂停1秒，控制循环时间
def person():
    global state
    n = 0#人员编号
    while True:
        if even.is_set():
            print('我是人：门开着：{}号进入'.format(n))
        else:
            even.set()#将even事件标记为真
            state = 0#开门循环重置为0
            print('我是人：门关着，{}号人刷卡进门'.format(n))
        n += 1
        sleep(randint(1, 10))#随机1-10米秒来一个人，模拟刷卡
if __name__ == '__main__':
    state = 0
    even = Event()
    even.set()
    d = Thread(target=door)
    d.start()
    p = Thread(target=person)
    p.start()

老师，在执行的时候应该先提示

我是门：门关了~请刷卡！

但是我的这个程序，直接就是开着门的，请帮忙看看问题在哪里，谢谢

#coding=utf-8

from socket import *
from threading import Thread


def recv_data():
   while True:
       recv_data = client_scoket.recv(1024)
       print(f"收到信息:{recv_data.decode('gbk')},来自:

”在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。“   这句话怎么理解？不应该死掉吗？