老师我这个运行的时候没有任何的结果，直接显示程序结束了

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()
if __name__=="__mian__":
    lock=RLock()
    func3()

老师我有点糊涂了 

if __name__=='__main__' 这个一般怎么用

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


def func1(name):
    print(f"线程{name},start")
    for i in range(3):
        print(f"线程:{name},{i}")
        sleep(5)
    print(f"线程{name},end")

if __name__ == '__main__':
    print("主线程，start")
    #创建线程
    t1 = Thread(target=func1,args=("t1,"))
    t2 = Thread(target=func1,args=("t2,"))
    #启动线程
    t1.start()
    t2.start()
    print("主线程，end")

老师 这个是怎么回事呢

老师，上面这条语句的作用是什么，刚开始使锁处于False状态，怎样会变成True呢？

redata[1]是什么意思

您好，能不能详细说明一下Pool.apply 同步和Pool.apply_async 异步是什么意思？

本地IP地址感觉不对，但也不知道是什么，接受的内容是其他编码，这是为什么？

老师我这代码运行的样子怎么是这样的？然后每次的样子还不一样

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()

老师您好，在学完进程通信章节后，我的第一感觉是这种操作类似于操作文件夹。即是说，Quene是一个存储消息的“文件夹”，通过put和get来对文件夹里的内容进行储存和取出。请问可以这样理解吗？如果对您能再给补充下吗？如果不对还请老师您批评指正，谢谢！

默认子进程不共享主进程中的全局变量，当进行进程通信的时候即Queue中的信息可以共享是吗？

#encoding=utf-8

#方法方式创建线程

from threading import Thread

from time import sleep

def func1(name):

  for i in range(3):

    print(f"thread:{name} :{i}")

    sleep(1)

if __name__ == '__main__':

  print("主线程，start")

  #创建线程

  t1 = Thread(target=func1,args=("t1",))

  t2 = Thread(target=func1,args=("t2",))

  #启动线程

  t1.start()

  t2.start()

  print("主线程，end")

'''

运行结果可能会出现换行问题，是因为多个线程抢夺控制台输出的IO流。

比如，如下的输出换行就没有按照预想的显示：

主线程，start

thread:t1 :0

thread:t2 :0

主线程，end

thread:t2 :1thread:t1 :1

thread:t2 :2

thread:t1 :2

'''

老师 还有我不太理解这个逻辑顺序

一、代码

#coding=utf-8

import threading
import time
from queue import Queue

class Pro(threading.Thread):
    def run(self):
        global q
        count=0
        while True:
            if q.qsize()<1000:
                for i in range(100):
                    count = count+1
                    msg = "生成产品"+str(count)
                    q.put(msg)
                    print(msg)
            time.sleep(1)

class Con(threading.Thread):
    def run(self):
        global q
        while True:
            if q.qsize()>100:
                for i in range(3):
                    msg = self.name + "消费了" + q.get()
                    print(msg)
            time.sleep(1)


if __name__ == "__main__":
    q = Queue()
    for i in range(500):
        q.put("初始产品"+str(i))
    for i in range(2):
        p = Pro()
        p.start()
    for i in range(5):
        c = Con()
        c.start()

二、问题

1、

上述产生数据的两个进程是同时运行的还是一个运行完再运行下一个？

如其同时运行，当第一个进程已经往池中写入“生成产品1”，第二个进程还可以往里面写入“生成产品1”吗？

Queue   怎么删除里面的数据呢？

比如：
q=Queue()
q.put(1)
q.put(2)
q.put(3)
如何删除3呢？

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)
if __name__ == "__main__":
    
    # 创建线程
    t1 = MyThread('t1')
    t2 = MyThread('t2')

    # 启动线程
    t1.start()
    t2.start()

老师我看了好多类的继承这样的写法，在子类的构造方法里都会调用父类的构造方法，这是固定写法吗？

如果是的话换成用super()去调用这样写可以吗？

"!H5sb5sb" #这个是正则表达式吗？？？