这里为什么要用循环啊，不太

明白

老师我这个线程1和2怎么是同一时间运行完的，怎么没有执行完线程1睡上3秒后，再执行线程2.

from threading import Thread
from time import sleep

#线程的实现
#方法包装

#创建普通方法
def func1(name):
    print(f"Threading:{name}start")
    sleep(3)

#创建线程
t1=Thread(target=func1,args=('t1',))

t2=Thread(target=func1,args=('t2',))

#开始线程
t1.start()
t2.start()

1. 为什么Threading:t3 end 和 Threading:t2 end  之间没有自动换行？

2. 代码：

from threading import Thread
from time import sleep,time
import threading
def func1(name):
    #print(threading.currentThread())
    print(f"Threading:{name} start")
    sleep(3)
    print(f"Threading:{name} end")
if __name__ == '__main__':
    #print(threading.currentThread())
    #开始时间
    start = time()
    thread_list = []
    for i in range(3):
        t = Thread(target=func1, args=(f"t{i+1}",))
        thread_list.append(t)
        t.start()

    for t in thread_list:
        t.join()

    #结束时间
    end = time() - start
    print(end)

3.运行结果：
Threading:t1 start
Threading:t2 start
Threading:t3 start
Threading:t1 end
Threading:t3 endThreading:t2 end

3.002171754837036

Process finished with exit code 0

老师,这里这个f是什么意思,表示什么

import gevent


def gf(name):
    print(f'{name}:我想买包包！！')
    gevent.sleep(1)
    print(f'{name}:我想学编程！！')
    g2.switch()
def bf(name):
    print(f'{name} :买买买')
    gevent.sleep(1)
    print(f'{name} :一定去尚学堂')

if __name__ == '__main__':

    g1 = gevent.spawn(gf, '貂蝉')
    g2 = gevent.spawn(bf, '吕布')
    #切换任务
    g1.join()
    g2.join()

AttributeError: module 'gevent' has no attribute 'spawn'

我已经安装包了，不知道为什么还会报错

老师您好，在学完线程同步后我也查了下异步相关的资料，即“同步有序、异步无序”，那么在不用锁等方式进行同步的情况下，默认是不是就是异步的？

老师，为啥TCP服务器端发送消息和TCP客户端发送消息时，调用的对象都是TCP套接字客户端对象client_soket，服务器发送消息的时候，调用的对象不应该是server_soket吗？而且不管是客户端还是服务端，在发送消息和接收消息的时候调用的对象都是客户端套接字对象client_soket，服务器套接字对象server_soket一直都没有用上

请问协程不是在IO的时候会切换到另一任务吗，为什么缺点里却又会阻塞整个程序？

'''
生产者消费模型
'''
from threading import Thread
from time import sleep
from queue import Queue


def producer():
    num = 1
    while mq.not_empty:
        print("王大娘做了第{}个包子".format(num))
        mq.put(f"王大娘做的第{num}个包子")
        num += 1
        sleep(2)
    else:
        print("吃的太快了")


def consumer(name, count):
    while mq.not_empty:
        m = mq.get()
        print("{}吃了第{}个包子".format(name, m))
        sleep(count)
    else:
        sleep(5)

if __name__ == '__main__':
    mq = Queue()
    t1 = Thread(target=producer)
    t2 = Thread(target=consumer, args=("张三", 3))
    t3 = Thread(target=consumer, args=("李四", 1))
    t4 = Thread(target=consumer, args=("王五", 1))
    t1.start()
    t2.start()
    t3.start()
    t4.start()

老师，我这包子两秒钟做一个，但是吃包子的最快一秒一个，为啥生产者中的print("吃的太快了")没有执行，还是做一个吃一个

注释掉join()，主线程应该也能完成才对吧

老师，帮忙看一下为什么停到这里了

老师我，为什么会报这个错误

import asyncio
import functools


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


async def out_sum(x, y):
    # 创建任务task
    task = asyncio.create_task(compute(x, y))
    # 给task绑定回调函数
    task.add_done_callback(functools.partial(end, x, y))
    await asyncio.sleep(2)


async def end(n, m, t):
    # t是task对象，通过t获取task对象运行的结果
    print(f'{n}+{m}={t.result()}')


if __name__ == '__main__':
    # 创建循环
    EventLoop = asyncio.get_event_loop()
    # 监听循环
    EventLoop.run_until_complete(out_sum(1, 2))
    EventLoop.close()

一次性最多能创建多少个进程？这个界限是怎么判定的？

老师，请问，这是哪里出错了呢，我检查了也没发现

老师，这个并行运行是同时运行吗？通过这几个程序，发现这些线程一样也是有先后顺序执行的。我可以理解为这里面的每个线程都是由自己的执行时间的，然后谁需要的时间短就先执行谁（或者说谁先抢占到CPU就此案执行），然后再继续执行下一个线程吗？