老师,greenlet的main greenlet是什么

socket *
threading Thread


():
    :
        recv_data = s.recvfrom()recv_content = recv_data[].decode()
        (recv_data[].decode()recv_data[])
        recv_content == :
            ()
            ():
    addr = (, )
    :
        data = ()
        s.sendto(data.encode(), addr)
        data == :
            ()
            __name__ == :
    s = socket(AF_INET,SOCK_DGRAM)s.bind((,))t1 = Thread(=recv_data())
    t2 = Thread(=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()

socket *
threading Thread


():
    :
        recv_data = s.recvfrom()recv_content = recv_data[].decode()
        (recv_data[].decode()recv_data[])
        recv_content == :
            ()
            ():
    addr = (, )
    :
        data = ()
        s.sendto(data.encode(), addr)
        data == :
            ()
            __name__ == :
    s = socket(AF_INET,SOCK_DGRAM)s.bind((,))t1 = Thread(=recv_data())
    t2 = Thread(=send_data())
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    s.close
两个代码都运行没有结果

老师，还是不太明白为什么上述程序，先输出的process1，再输出“子程序运行中”，python程序不是按顺序执行的吗？

看了您之前的解释

那为什么，不加print（p.name）这条语句也应该先输出process-1啊？

还有下面的程序

#coding=utf-8

from multiprocessing import Process

def run():
    print("子进程运行中")
if __name__ == "__main__":
    print("父进程启动")
    p = Process(target=run)
    p.start()
    p.join()
    print(p.name)

输出结果却是：

麻烦老师解释一下，怎么Process-1又在后面执行了？

最后麻烦老师讲解一下，这一张讲解多线程的目的是什么，有点蒙，为什么从讲python程序调到了多线程课程？

老师，我看大家问的问题有的视频和笔记中都没有，除了这两，还有其他资料吗

在TCP编程3服务端和客户端持续通信这一节视频的5分15秒，按照老师打的recv_data显示错误，有以下报错。能帮看下吗？

from time import sleep
from threading import Thread
from threading import Event

def car():
    # global count
    num = 0
    while True:
        if even.is_set():
            print('车已到站，可以上车')
            sleep(1)
            # count += 1
            num += 1
            if num % 5 == 0:
                even.clear()
        else:
            print('车开走了....')
            sleep(6)
            # count = 1
            even.set()

def person():
    while True:
        # if count % 5 != 0:
        if even.is_set():
            print('上车！！')
            sleep(1)
        else:
            print('等待车！！！')
            even.wait()
            # sleep(1)
if __name__ == "__main__":
    even = Event()
    # count = 1
    t1 = Thread(target=car)
    t2 = Thread(target=person)
    t1.start()
    t2.start()

true或者false是随机的？为什么每次程序执行都是执行else后面的语句

import multiprocessing
import time

def worker(interval):
    n = 5
    while n > 0:
        print("The time is {0}".format(time.ctime()))
        time.sleep(interval)
        n -= 1

if __name__ == "__main__":
    p = multiprocessing.Process(target = worker, args = (3,))
    p.start()
    print ("p.pid:", p.pid)
    print ("p.name:", p.name)
    print ("p.is_alive:", p.is_alive())

在执行了p.start()后不就是调用了p.run（）方法吗？那么主进程中的print打印，和子进程中的print语句是同时执行吗？

老师请问为什么我这个运行后打印的数据长度只有2的？
from socket import *
import struct

filename='cui.jpg'  # 创建一个存放要下载的文件的变量
server_ip='192.168.1.60'  # 创建一个存放IP地址的变量
# 创建读写请求
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))  # 发送信息
f=open(filename,'ab')  # 创建新的同名的空文件 以追加形式打开
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:  #操作码是5的话 就是文件不存在 是一个错误包
        print('文件不存在。。')
        break
    print('操作码: %d,ACK: %d,服务器随机端口: %d,数据长度:%d'%(caozuoma,ack_num,rand_port,len(recv_data)))
    f.write(recv_data[0][4:])  # 将512个字节的数据写入
    if len(recv_data[0])<516:  # 如果收到的数据少于516个字节，说明发送完毕了
        break
    ack_data=struct.pack('!HH',4,ack_num) # 发送确认包 4+块编号
    s.sendto(ack_data,(server_ip,rand_port))

如果某个协程已经是dead状态，那么再切换进去将会切换到父协程，就会执行父协程。老师能给我讲讲这是个怎么回事吗？

t1=Thread()

老师你是怎么导入模块的

老师，

1、if已设置队列小于10，为什么一直生产，不停止

2、当最大容量设置10时，为什么生产到13，前2个为什么已存储在容器中

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”，才接收到信息，如果输入其他的，则是一直显示请输入

#encoding=utf-8
from socket import *
from threading import Thread
s=socket(AF_INET,SOCK_DGRAM)
s.bind(("127.0.0.1",8080))


def recv_data():
    while True:
        recv_data=s.recvfrom(1024)
        print("等待接收数据！")
        udp_data=recv_data[0].decode("gbk")
        print(f"接收的数据：{udp_data},from{recv_data[1]}")
        if udp_data=="88":
            print("结束聊天！")
            break

def send_data():
    while True:
        addr = ("127.0.0.1",8989)
        data=input("请输入数据：")
        s.sendto(data.encode("gbk"),addr)
if __name__=="__main__":
    t1=Thread(target=recv_data)
    t2=Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

from threading import Thread
from time import sleep,time
import threading
# Thread:线  
# 线程的实现
# 方法包装

# 创建普通方法
def func1(name):
    print(threading.currentThread())
    print(f"Threading:{name} start")  # f:输出一下哪个线程启动了,print语句一般都是提示信息,
    sleep(3)                           #不加也可以只是不会输出在控制台上(这里指的是name)
    print(f"Threading:{name} end")

if __name__ == "__main__":

    print(threading.currentThread())   # 打印默认的主线程 <_MainThread(MainThread, started 1068)>
    # 开始时间
    start = time()   # 时间测试
    '''
    # 创建线程
    t1 = Thread(target=func1,args=('t1',))  # t1后面加, 必须是元组     # 创建的是子线程
    t2 = Thread(target=func1,args=("t2",))
    # 开始时间
    start = time()
    # 开始线程
    t1.start()
    t2.start()
    # 等待t1线程执行完再往下执行
    t1.join()
    # 等待t2线程执行完再往下执行
    t2.join()
    #func1("t1")
    #func1("t2")
    '''
    thread_list = []
    for i in range(10):
        t = Thread(target=func1,args=(f"t{i+1}",))
        t.start()
        thread_list.append(t)
    for t in thread_list:
        t.join()    # join的使用 不要启动线程后立即join(),容易造成串行运行，导致并发失效
    # 结束时间
    end = time()-start
    print(end)

老师 这里多任务的实现是用了多线程模式方法吗 这里循环10个进程是子线程 主线程只有一个 就是MainThread吗

老师您受累看一下，我把顺序写在图片中了 不知道是不是这样的一个意思