import socket from threading import Thread def dealclient(newsocket,destadd):     while True:         recvdata = newsocket.recv(1024)         if len(recvdata) >0:             print(recvdata)         else:             print('数据接收完毕',destadd)             break     newsocket.close() if __name__ == '__main__':     tcpserver = socket.socket(socket.AF_INET,socket.SOCK_STREAM)     tcpserver.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#设置这个以后可以同时处理多个请求     add = ('',7788)     tcpserver.bind(add)     tcpserver.listen(5)     while True:         print('主进程等待连接')         newsocket,destadd = tcpserver.accept()         t0 = Thread(target=dealclient,args=(newsocket,destadd))  #因为已经传递了参数，所以可以在主进程中关闭         t0.start()         newsocket.close()

为什么我这里用线程，就出错了，而用进程却不出错

有点不明白程序运行的逻辑是怎么样的过程？

1，这里创建类对象

2，这里的功能把类对象传递给threadlocal,
是不是同时也是绑定了当前线程到threadlocal?

3，调用函数deal_student

4，从threadlocal获取当前线程的关联性？

5，是否对类对象的调用不用写？

6，变量stu是否会发生混乱？局部变量？
stu类对象保存在threadlocal中吗？

对于传递的问题总感觉云里雾里，希望老师能够解答疑惑。

老师，这是什么情况

老师 这个守护线程已经调用析构函数 为什么还会继续执行呢

您好，想问一下，视频中说设定mq=Queue(maxsize=10),为什么说生产了3到13号加菲猫是10只，3到13不是11个数吗？而且，如果用if mq.qsize() <10,那么只会生产到第12号加菲猫

from threading import Thread
from time import sleep,time

def func1(name):
    print('Thread:{0} start...'.format(name))
    sleep(3)
    print('Thread:{0} end...'.format(name))

if __name__ == '__main__':
    start=time()
    t_list=[]
    for i in range(5):
        t1=Thread(target=func1,args=('t{}'.format(i),))
        t1.start()
        t_list.append(t1)
    for t1 in t_list:
        t1.join()
    end=time()-start
    print(end)
    
    老师，为什么end这一块，它的显示顺序和start不一样是乱序的，而且end那里间距那么大；还有join函数是
    一个线程执行完毕后，再执行另一个线程的意思么

from threading import Thread
from time import sleep
import time


# 创建普通方法
def func(name):
    print(f'Threading:{name} start')
    sleep(3)     # 执行完上一语句后睡眠 3s


# 创建线程
# target 属性是告诉线程要调用哪个方法，args 属性把参数传进去。即 args 是目标调用的参数元组，默认为空元组 ()
t1 = Thread(target=func, args=('t1',))
t2 = Thread(target=func, args=('t2',))

# 开启线程，通过 start() 方法
time01 = time.time()
t1.start()
t2.start()
time02 = time.time()
print(f'通过start()开启线程的时间是：{time02-time01}')


# 正常通过函数调用执行
time03 = time.time()
func('t1')
func('t2')
time04 = time.time()
print(f'通过函数调用执行的时间是：{time04-time03}')

运行结果：

问题：

1、多线程方式执行是 t1 和 t2 同时执行，也调用了函数 func，执行了里面的语句。那么多线程执行的时间不应该是 3 秒多一点吗？

2、正常调用函数执行时是 func('t1')，传参数时为什么要给 t1 和 t2 加引号？

count已经设置了全局变量，下面的为什么没反应，有没有什么方法可以让它也改变值

#coding=utf-8
from threading import Thread
from threading import Event
from time import sleep
from random import randint

global count #  设置了全局变量
def door():
    while True:

        if even.is_set():
            print("门已经开启,快进入")
            sleep(1)
            # even.wait
            if count > 3:
                print("超过3秒,门自动关闭")
                even.clear()
        else:
            count = 0
            print("门已关闭")
            # even.clear(): 写错了 ,门是被动的,人来了门就会开启,所以应该用wait.
            even.wait()
        count += 1


def person():
    num = 0
    while True:
        num += 1
        if even.is_set():

            print(f"门开着的,进去{num}人")
            count = 0 # 这个数值没办法给上面传输过去
        else:
            even.set()

            print(f"{num}刷卡开门通行")
        sleep(randint(1, 10))


if __name__ == "__main__":
    # 先开2个线程
    even = Event()
    t1 = Thread(target=door)
    t2 = Thread(target=person)
    t1.start()
    t2.start()

学完并发编程没有感觉到实际的应用,老师，后期我们会有并发编程实际应用的课程么？而且task好难理解，先跳过的话对以后会不会有影响？

老师 tcp怎么没笔记

为什么我的守护线程没有实现效果

import time
from threading import Thread

#通过类包装

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

    def run(self):
        print(f'{self.name},start')
        for i in range(3):
            print(f'{self.name}线程：{i}')
            time.sleep(3)
        print(f'{self.name}线程，end')

if __name__ == '__main__':
    print('主线程start')

    t1 = MyThread('t1')
    t2 = MyThread('t2')
    t1.daemon =True

    t1.start()
    t2.start()
    #等t1,t2线程结束才会继续执行主线程



    print('主线程end')

我的主线程都已经结束了，为什么t1还是会继续执行？？？

import asyncio
# @asyncio.coroutines 3.5之前


def func01():
    for i in range(10):
        print("python是世界上最好的语言")



if __name__ == '__main__':
    func01()
    # 创建事件循环
    loop = asyncio.get_event_loop()
    # 监听事件循环
    loop.run_until_complete(func01())
    # 关闭事件循环
    loop.close()

老师我代码和视频一样的，没有问题我什么这个会报这样的错误呢

from threading import  Thread
from time import sleep

#创建类
class Threading1(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(f'threading:{self.name}start')
        sleep(1.5)
        print(f'threading:{self.name}end')
if __name__=='__main__':
    #创建线程
    for i in range(20000):

       t=Threading1(f't{i+1}')
       #设置当前进程为守护线程
       t.setDaemon(True)
       t.start()
    print('主进程结束了！！！！！！')

问题1：如果这样的话守护线程不是没有意义了吗？

问题2：如果守护线程的作用到底是什么？

请老师解答 谢谢

老师，我有点迷糊，那这样做是怎么变快的呢，他实际上不还是一步步的走吗，并没有多个线程一同工作呀

老师，我这写的为什么没有运行结果