如果多个线程都已经调用了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')},来自:

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

老师，您好，就是这章节的哪两个软件怎么下载啊？那个网络通信的和那个Tftpd 32 by phJounin.

我去百度下载Tftpd 32 by phJounin后直接是流氓软件。。。

然后现在就是看完视频敲完代码也是懵逼状态，代码没有运行成老师讲解的那样子。

老师，下面的callback回调函数的作用是什么？写与不写的区别在哪里？好像不影响进程的效率

p.apply_async(func=func1, args=(f"p{i+1}", ), callback=func2)

老师。你这里是怎么实现选择全部输入#号的？具体的操作步骤是什么??

from multiprocessing import Process
num = 1
def run1():
    global num
    num += 15
    print("子进程1的数字是：%d"%num)
def run2():
    global num
    num += 100
    print("子进程2的数字是：%d"%num)

if __name__ == '__main__':
    print("父进程启动")
    p = Process(target=run1, name="one1")
    p1 = Process(target=run2, name="two2")
    print("开始执行子程序")
    p.start()
    p1.start()
    p.join()
    p1.join()
    print(num)
    print("进程结束")

老师，我运算的结果，为什么是这样的？

#coding=utf-8
from threading import Thread
from time import sleep,time
#创建方法
def func1(name):
    print(f"threading:{name}start")
    sleep(3)
    print(f"threading:{name}end")
if __name__ == '__main__':
    #启动时间
    start = time()

    t_list = []
    for i in range(10):
        t = Thread(target=func1, args=(f"t{i+1}",))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    end = time()-start
    print(end)
    
#coding=utf-8
from threading import Thread
from time import sleep,time
import threading
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        print()
        print(f"threading:{self.name}start")
        sleep(3)
        print(f"threading:{self.name}end")
if __name__ == '__main__':

    start = time()
    t_list = []
    for i in range(10):
        t = MyThread(f"t{i+1}")
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    end = time()-start
    print(end)

哪些是主进程哪些是子进程,哪些是主线程哪些是子线程.

有点搞不清楚有点乱

请问下 print（f‘（门开着。。。{}号人进入））里的f是什么意思

老师比如这里不给飞秋发内容，给微信，QQ发要怎么整？？？？？？协议又不一样了是吧？？？？？？？？？？？？？

老师，这些进程，都是做什么用的？学这些，的目的是什么？

from threading import Thread
from time import sleep


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

    def run(self):
        print(f'Threading：{self.name} start')
        sleep(3)
        print(f'Threading：{self.name} end')


if __name__ == '__main__':
    for i in range(20):
        t = MyThread(f't{i+1}')
        t.setDaemon(True)     # 设置当前线程为守护线程，值默认为 False
        t.start()

    print('主线程结束了！！！')

老师，我还是不太理解这个程序中语句的执行顺序。

我在 if __name__ == '__main__'  这条语句前打断点，发现该程序语句执行顺序如下：

1、执行  for i in range(20)                #  i = 0
2、执行  t = MyThread(f't{i+1}')       #  t = t1

3、执行 def __init__(self, name)

4、执行 Thread.__init__(self)
5、执行 slef.name = name

6、执行  for i in range(20)                #  i = 1

......

7、循环结束，执行 print('主线程结束了！！！')

问题：

1、程序是从上往下执行的，所以首先应该是创建类对象，这个类对象代表的是类 MyThrad 的结构，里面包含实例方法 run 。然后进入程序入口，执行 for 循环里的语句，执行  t = MyThread(f't{i+1}') 语句时，会先调用 __new__() 方法创建一个实例对象，再用 __init__() 方法初始化这个实例对象，其中实例对象里也有实例属性和 run 方法。我这样理解是对的吗？

2、按照我打断点后语句的执行顺序，并没有发现执行 run 方法。请问老师，这个 run 方法是怎么调用的？什么时候调用的？