老师，为什么多线程所需要的的时间比睡眠时间 * n还要多一点？是因为切换线程需要时间吗？我的电脑CPU是8核，创建了10个线程，如果是，为什么有时候单线程后面的秒数又多些？

为什么每次运行时，打印出来的时间都是不一样的？

from multiprocessing import Process, current_process,Pipe
import os

def func1(name, con):
    print(f"进程ID{os.getpid()}获取了数据：{con.recv()}")
    con.send("你好！")

if __name__ == "__main__":
    print(f"进程ID：{current_process().pid}")
    con1, con2 = Pipe()
    p1 = Process(target=func1, args=("p1", con1))
    p1.start()
    con2.send("hello!")

    print(con2.recv())

con是个 啥，从哪冒出来的

from threading import Thread
from queue import   Queue
from time import sleep


def producer():
    num = 1
    while True:
        # if mq.qsize() < 10:
        print(f"生产了{num}号加菲猫")
        mq.put(f"{num}号加菲猫")
        num += 1
        sleep(1)

def consumer():
    #while True:
    print("购买了{}".format(mq.get()))
    sleep(2)

if __name__ == "__main__":
    # 创建共享数据的容器
    mq = Queue(maxsize=10)
    # 创建生产者线程
    t1 = Thread(target=producer)
    # 创建消费者线程
    t2 = Thread(target=consumer)
    t3 = Thread(target=consumer)
    # 开始工作
    t1.start()
    t2.start()
    t3.start()

老师，queue队列里的数据是不是 get（）之后就消失了

老师，为啥我画横线那块不能像注释里那样写，提示不对

from threading import Thread
from queue import   Queue
from time import sleep


def producer():
    num = 1
    while True:
        print(f"生产了{num}号加菲猫")
        my.put(f"{num}号加菲猫")

def consumer():
    while True:
        print(f"购买了{mq.get()}")
        print("购买了{}".format(mq.get()))

if __name__ == "__main__":
    # 创建共享数据的容器
    mq = Queue()
    # 创建生产者线程
    t1 = Thread(target=producer)
    # 创建消费者线程
    t2 = Thread(target=consumer)
    # 开始工作
    t1.start()
    t2.start()

老师，请问一下面这个是什么意思，没有理解

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(10):
        t = MyThread(f"t{i+1}")
        #设置当前进程为  守护线程
        t.setDaemon(True)
        t.start()
    print("主进程结束！")

老师，请问下这是怎么了呢，在VS code里面写的

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()
    t1 = Thread(target=func1, args=('t1',))
    t2 = Thread(target=func1, args=('t2',))

    t1.start()
    t2.start()
    # func1('t1')
    # func1('t2')
    # 计算使用时间
    end = time() - start
    print(end)

运行结果：

老师，怎么看代码中，哪一块是主线程，哪一块是子线程

请问必须要写gevent.sleep（）吗？我试了一下不写的话，并没有切换的效果；

而且如果gevent.sleep()这样写，会有切换的效果，而且特别快

# 信号量
from time import sleep
from threading import Thread
from threading import BoundedSemaphore


def an_jian(num):
    lock.acquire()
    print(f'第{num}个人完成安检')
    sleep(2)
    lock.release()


if __name__ == "__main__":
    lock = BoundedSemaphore(3)
    for i in range(10):
        t = Thread(target=an_jian, args=(f'{i+1}',))
        t.start()

老师，为啥输出的结果是参差不齐的呢~~

from multiprocessing import Process, Semaphore, Lock, Queue
import time

empty = Semaphore(2)
full = Semaphore(0)
lock = Lock()


class Consumer(Process):
    def __init__(self, buffer):
        Process.__init__(self)
        self.buffer = buffer

    def run(self):
        while True:
            full.acquire()
            lock.acquire()
            info = self.buffer.get()
            print('Consumer pop an element',info)
            time.sleep(1)
            lock.release()
            empty.release()


class Producer(Process):
    def __init__(self, buffer):
        Process.__init__(self)
        self.buffer = buffer

    def run(self):
        while True:
            empty.acquire()
            lock.acquire()
            self.buffer.put('bmt')
            print('Producer append an element')
            time.sleep(1)
            lock.release()

            full.release()


if __name__ == '__main__':
    buffer = Queue(10)
    p = Producer(buffer)
    c = Consumer(buffer)
    p.daemon = True
    c.daemon = True
    p.start()
    c.start()
    p.join() 
    c.join()
   

    print('Ended!')

老师，这个代码只输出两个

Producer append an element

Producer append an element

就卡住不执行了，老师帮我分析下，谢谢！

# coding=utf-8
from threading import Thread
import time

def threading_test(name):
    i=500000000
    q=1
    for a in range(i):
        q = q+a
    #print(q)
    #print(f'任务{name}执行完')


t1= Thread(target=threading_test,args=('t1',))
t2= Thread(target=threading_test,args=('t2',))

s1=time.time()

t1.start()
t2.start()
t1.join()
t2.join()
s2=time.time()
print('多线程时间是',s2-s1)



s3=time.time()
t3 = threading_test('t3')
t4 = threading_test('t4')
s4= time.time()
print('普通时间是',s4-s3)

老师你好，这个代码为了测试多线程和串行的时间，运行结果如下：

一个81s,一个88s,感觉区别也不大嘛，是我代码设置的时间截取不对么还是什么什么问题？

谢谢老师

# coding=utf-8
from threading import Thread
import time

def threading_test(name):
    i=50000000
    q=1
    for a in range(i):
        q = q+a
    print(q)
    print(f'任务{name}执行完')


t1= Thread(target=threading_test,args=('t1',))
t2= Thread(target=threading_test,args=('t2',))

s1=time.time()
t1.start()
t2.start()
s2=time.time()
print('多线程时间是',s2-s1)

老师你好， 我想测试一下多线程和普通方法运行的时间差异，所以就写了这段代码。这是运行截图

运行结果和我想的不一样。

理论上应该是先打印运行结果  在打印时间。

但是它是先打印时间  在打印运行结果。而且打印出时间后 隔了一段时间才打印出运行结果 所以这个时间应该也是不对的。

我不知道代码哪里问题了，在普通方式里是没问题的，运行出结果要8秒。推算的话多线程执行也要4秒。

麻烦老师帮我看一下哪里出问题了，应该是多线程的启动机制我没理解到位。

谢谢老师~

from threading import Thread
from socket import *


s1 = socket(AF_INET, SOCK_DGRAM)
s1.bind(('', 8788))
s2 = socket(AF_INET, SOCK_DGRAM)
s2.bind(("", 8587))


def func1():
    while True:
        func1_data = input("func1：")
        s1.sendto(func1_data.encode(), ("192.168.1.101", 8587))
        func2()
        redata = s1.recvfrom(1024)
        print("func2：{}".format(redata[0].decode()))


def func2():
    recvData = s2.recvfrom(1024)
    print("func1：{}".format(recvData[0].decode()))
    func2_data = input("func2：")
    s2.sendto(func2_data.encode(), recvData[1])


if __name__ == '__main__':
    t1 = Thread(target=func1())
    t1.start()

结果：

老师我这个虽然实现了聊天功能，但是感觉不算线程吧

老师，您好。想请教个问题，(没有在网上搜到明确的回答)如图：

#服务端
from socket import *

serverSocket = socket(AF_INET, SOCK_DGRAM)
serverSocket.bind(("", 1818))
serverSocket.listen(8)

#newSocket, clientaddr = serverSocket.accept()

while True:
    newSocket, clientaddr = serverSocket.accept()

    #while True:  
    data = newSocket.recv(1024)
    if len(data) > 0:
        print(data.decode("utf-8"))
    else:
        break
    #发送数据给客户端
    newSocket.send("连接完成...")
    senddata = input()
    newSocket.send(senddata.encode("utf-8"))
newSocket.close()
#serverSocket.close()

#客户端
from socket import *



clientSocket = socket(AF_INET, SOCK_STREAM)
clientSocket.connect(('192.168.1.5', 1818))
clientSocket.send("您好，请求连接")
while True:
    data = clientSocket.recv(1024)
    print(data)
    # 实现输入消息的功能：
    sendData = input("请输入您给对方想发送的消息:")
    if len(sendData)>0:
        clientSocket.send(sendData.encode("utf-8"))
    else:
        break

老师，您好。想请问一下，

newSocket, clientaddr = serverSocket.accept()

这行代码，该怎么理解？ accept()接收的到内容具体是哪些？