from threading import Thread
from time import sleep, time


def func():
    global count
    for i in range(10000):
        count += 1


count = 0
start = time()
# for i in range(10):
#     t = Thread(target=func)
#     t.start()
# print(f"count = {count}")
for i in range(10):
    func()
print(f"count = {count}")
end = time() - start
print(end)

老师，注释内容和后续循环都能正确打印出结果，但是我发现打印出来的时间反而是多线程耗时更多一点，多次运行后发现要么是多线程运行耗时多，要么二者速度差不多。这样的话Python的多线程还有什么意义呢，没感觉到效率的提升啊。

from socket import *
s = socket(AF_INET, SOCK_DGRAM)
s.sendto("钟呢呢".encode("gb2312"), ("192.168.145.1", 8080))

请问同步执行和异步执行是什么？有什么区别？

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

老师我这吧下载的网络助手显示乱码，是我电脑设置的问题吗

from socket import *

tcpsock=socket(AF_INET,SOCK_STREAM)
tcpsock.bind(("",8899))  #  默认本机ip
tcpsock.listen(5)   #  最多有5个人可以排队
newsock,clientaddr = tcpsock.accept()   #  返回一个新的套接字对象(空出用于接收连接请求的端口)，连接方地址
data = newsock.recv(1024)  # 注意在tcp里不是recvfrom，是recv
print(data)

newsock.send("xiexie")   # 方法是send，在做三次握手的时候已经建立了稳定的连接

newsock.close()

tcpsock.close()  #  关闭作为监听的套接字

from socket import *
clientsock=socket(AF_INET,SOCK_STREAM)
clientsock.connect(("192.168.1.1",8899))  #  客户端同样要用7788端口,连接服务器
clientsock.send("nihao")
data = clientsock.recv(1024)
print(data)
clientsock.close()

先运行服务器，再运行客户端没有反应，或者提示通常每个套接字地址(协议/网络地址/端口)只允许使用一次。

老师第一个问题  关于这个事件 视频中老师举了两个例子 其实还是说明有两个线程 在调用一个方法的时候 可以通过事件event的一个状态来设置什么时候ti这个线程可以进入   什么时候t2这个线程可以进入 不管是车来了还是门开了 都是在说明这个问题 可以这样理解吗 

第二个问题 不管车来了还是门开了这两个例子里t1和t2线程 他们是并行还是串行  弄的有点混乱

这个老师讲的并发编程是真的听不懂啊 这应该怎么整  好多点都没有讲透彻 这部分有没有高琪老师讲的

from threading import Thread
from threading import Lock
#锁的目的 是为了保护数据的安全性
def func1(name):
    lock.acquire() #获取锁
    global count
    for i in range(100):
        count += 1
    lock.release() #释放锁 

if __name__ == "__main__":
    count=0
    t_list=[]
    lock=Lock()  #创建锁
    for i in range(10):
        t=Thread(target=func1,args=(f"t{i+1}",))
        t.start()
        t_list.append(t)
    for i in t_list:
        t.join()
    print(count)

老师  这个count循环是不是这样的   子线程每调用一次func1这个方法 里面的count就加100个1  因为是10的子线程所以最后打印count是1000  可以这样理解吗

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")
print(threading.currentThread())
#创建线程
t1=Thread(target=func1,args=("t1",))
t2=Thread(target=func1,args=("t2",))

#开始时间
start=time()
#开始线程
t1.start()
t2.start()
#结束时间
end=time()-start
print(end)

老师 这里这个时间0.00096是在 Threading：t1 start 后边才打印的   视频中老师不是说过 这个时间是在子线程开始之后就打印了  并没有将子线程的方法算到这个时间里边  这不是矛盾了吗

from threading import Thread
from time import sleep,time
#方法包装

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

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

#开始时间
start=time()
#开始线程
t1.start()
t2.start()
#结束时间
end=time()-start
print(end)

老师 这个时间就是指  从主线程创建两个子线程到子线程开始的时间  并没有等到子线程去调用方法（也就是子线程结束）  可以这样理解吗

from threading import Thread

#类实现，多线程
class MyThread(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name=name

    def run(self):
        print(f"Threading:{0} start".format(self.name)) #我用的format方法

#创建线程
t1=MyThread("t1")
t2=MyThread("t2")
#启动线程
t1.start()
t2.start()

老师 我用的是format的方法 为什么没有打印线程的名字

from threading import Thread
import time


class MyThread(Thread):

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

    def run(self):         # run 方法是规定好的， 不能改作其他名字
        print("Threading:{} start".format(self.name))
        time.sleep(3)

if __name__ == "__main__":
    t1 = MyThread('t1')
    t2 = MyThread('t2')
    t1.start()         # 开启线程，用start方法
    t2.start()

老师，初始化的时候为啥调用父类Thread的初始化方法，是因为重写了父类方法吗

想问一下老师，为什么不是先执行完for循环后再打印最后一句“主线程结束了”

from threading import Thread
#测试线程的同时进行，导入sleep模块
from time import sleep
#创建方法
class MyThread(Thread):#继承Thread类
    def __init__(self,name):
        Thread.__init__(self) #因为重写了方法，所以手动调父类的构造函数
        self.name=name
    def run(self): #一定要用run（）方法
        print("threading:{} satrt".format(self.name))
        sleep(3)
        print("threading:{} end".format(self.name))

if __name__ == '__main__':
    threadlist=[]
    for i in range(10):
        t=MyThread(f"t{i+1}")
        t.start()
    print("主线程结束了！！")

from socket import *


tcpSock = socket(AF_INET, SOCK_STREAM) #SOCK_STREAM 表示TCP
tcpSock.bind("", 7788) #默认使用7788端口做监听
tcpSock.listen(5) #最多只有5个同时监听
newSock, clientAddr = tcpSock.accept() #.accept()等待别人和自己创立链接


newSock.recv(1024)
newSock.send(b"xiexie")

newSock.close()

tcpSock.close()

老师请问这是什么情况