老师你好，是不是用锁的时候只要是  RLock()  就不会出现死锁？

问题：广播通信讲完就没有一个case去演示一下吗？老师，我感觉听着还是晕乎乎的，很虚

老师我的运行结果怎么这样？系统太随意了么？跟你的咋不一样?

import threading,time
num = 0
def work1():
    global num
    for i in range(100):
        num +=1
        print("in work1,num is %d"%num)
def work2():
    global num
    for i in range(100):
        num +=1
        print("in work2,num is %d"%num)
t1 = threading.Thread(target=work1)
t1.start()
t2 = threading.Thread(target=work2)
t2.start()
print("计算之后num=",num)

视频中代码：

# 进程间通信练习
import time
from multiprocessing import Process, Queue


def write():  # 这里不需要传参数q
    for value in ["a", "b", "c"]:
        print("start writing:", value)
        q.put(value)
        time.sleep(1)


def read():   # 这里不需要传参数q
    while True:
        if not q.empty():
            print("读取到的是", q.get())
            time.sleep(1)
        else:
            break


if __name__ == '__main__':
    q = Queue()
    q1 = Queue()
    pw = Process(target=write)
    pr = Process(target=read)
    pw.start()
    pw.join()  # 等待接收完毕，等待write()函数执行完毕
    pr.start()
    pr.join()
    print("接收完毕！")

write()和read()函数不需要传详细队列对象参数q，也能正常运行得到相同的结果。所以函数传q这个参数不是必须的吗？

这是上面代码运行的结果：

代码

socket *
struct
filename=server_ip=send_data = struct.pack(.format((filename))filename.encode().encode())
s=socket(AF_INETSOCK_DGRAM)
s.sendto(send_data(server_ip))
f=(filename)
:
    recv_data=s.recvfrom() caozuomaack_num=struct.unpack(recv_data[][:]) rand_port=recv_data[][] (caozuoma)==:
        ()
        (.format(caozuomaack_numrand_port(recv_data)))
    f.write(recv_data[][:]) (recv_data[])<:
        ()
        ack_data=struct.pack(ack_num)
    s.sendto(ack_data(server_iprand_port))

运行结果

提问：为什么数据长度都是2？而且下载的文件的空文件？

from threading import Thread
import time

class MyThread(Thread):

    def __init__(self, name) -> None:
        Thread.__init__(self)
        self.name = name
   
    def run(self):
        print(f"线程{self.name} start")

        print(time.time())
        for i in range(100):
            print(f"线程{self.name}:",i)
        time.sleep(3)
        print(time.time())

        print(f"线程{self.name} end ")

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

    # 创建线程
    t1 = MyThread("t1")
    t2 = MyThread("t2")
    # 守护线程 daemon
    t1.daemon = True
    t2.daemon = True
    # 启动线程
    t1.start()
    t2.start()
    # join()方法 等待子线程结束后再结束主线程
    # t1.join()
    # t2.join()

    print("主线程 end")

老师，这个代码我有几个问题：

1、主线程执行完毕和主线程结束不是一回事儿的话，主线程怎么样才算结束，是执行完毕后会有一个缓冲时间，去告诉系统，我执行完毕了，可以结束了吗？

2、这里执行结束后有这个报错，是我的代码问题吗，我和课上代码对比了没有发现代码哪里有问题呀；

3、这段代码里，我用time.time()方法试了一下，sleep函数貌似失效了，没有等待时间，是直接输出的，但是我不写在线程里，单独写一个测试sleep的代码的话是能正常使用的，这是什么原因。

import struct
from socket import *
filename="dog.jpd"
server_ip="192.168.1.41"
send_data=struct.pack("!H%dsb5sb"%len(filename),1,filename.encode(),0,"octet".encode(),0)
s=socket(AF_INET,SOCK_DGRAM)
s.sendto(send_data,(server_ip,69)) #发送读写请求
f=open(filename,"ab") #创建空文件
while True:
    recv_data=s.recvfrom(1024)#接收数据
    caozuoma,ack_num=struct.unpack("!HH",recv_data[0][:4])#获取数据块编号 哪一块数据
    rand_port=recv_data[1][1] #获取随机端口
    if int(caozuoma)==5: #说明丢包了
        print("文件不存在")
        break
    print("操作码：%d，ACK:%d,服务器随机端口：%d,数据长度：%d"%(caozuoma,ack_num,rand_port,len(recv_data)))
    f.write(recv_data[0][4:]) #将数据写入空文件
    if len(recv_data[0])<516:
        break
    ack_data=struct.pack("!HH",4,ack_num) #请求的格式
    s.sendto(ack_data,(server_ip,rand_port))#发送请求

老师这个数据长度是根据你的图片大小来定的吗  不同大小的数据 每次发送的数据块也是不一样的 对吧

老师您好，请问当我们使用Process时可以创建并执行子进程，但如果我们不做这些，直接在py文件里创建并执行函数又算是什么？并且在子进程操作全局变量后，再print全局变量其值不变，但如果不进程化，而是直接调用函数操作全局变量，最终全局变量的值是会改变的，请问为什么？

请问老师，Event.is_set()  刚开始判断True和Fslse  

也需要clear()和set（）来判断吗？

s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(("127.0.0.1",8888))
s.listen(5)

老师请问s.listen(5)里面的参数5是什么意思，是服务端可以链接的最大客户端数量吗？

老师，进程获取的数据是随机的吗

代码:

from threading import RLock
def func1():
    lock.acquire()
    print("func1拿到锁")
    func2()
    lock.release()
    print("func1释放锁")
def func2():
    lock.acquire()
    print("func2拿到锁")
    lock.release()
    print("func2释放锁")
def func3():
    func1()
    func2()
lock=RLock()
func3()

运行结果:

问题:

老师请问一下，在func1中嵌套了func2函数，当我们执行完func1拿到锁，func2拿到锁和func2释放锁以后，然后接下来不是应该先执行func1中的嵌套函数func2然后再输出func1释放锁吗?但是运行结果中为什么输出func2拿到锁和输出func2释放锁在输出func1释放锁的后面?

老师我已经在pycharm力安装好greenlet模块了，但为什么是程序里还是不能调用啊