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=(i + 1, ))
        t.start()

为什么不是第几个人，不是1-10的顺序？这个顺序好像是不固定的，而且有时候会导致换行符丢失！（同一行不隔开的打印两个人安检的信息）

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

input到底是在多进程还是多线程中不能用？

老师啊，这个物理层和数据链路层之间的区别是啥，我感觉我有点搞混了

老师这里args后面的元组，如果只有一个参数为啥一定要加逗号???????????????????

老师，为什么多线程并发编程中，Lock锁必须让变量引用以后才能使用？   

main(): lock = Lock()

function():lock.acquire() # 获得锁        lock.release() # 释放锁


而不能写成
function():Lock().acquire() # 获得锁      Lock().release() # 释放锁

下面那种写法，我的IDLE报错，我所使用的开发环境是PyCharm专业版

所以这个进程通信到底有啥用途，或者说，进程内相互通信这个倒底是什么意思

#coding=utf-8
#导入socket模块
from socket import *
from threading import Thread


def recv_data():
    while True:
        #接收服务端数据
        re_data=client_socket.recv(1024).decode('gbk')
        print(f'服务器端说：'{re_data})

def send_data():
    while True:
        msg=input(">")
        #向服务端发送数据
        client_socket.send(msg.encode('gbk'))
        if msg=='end':
            break

if __name__ == '__main__':
    # 创建socket对象
    client_socket = socket(AF_INET, SOCK_STREAM)
    #连接服务端
    client_socket.connect(('127.0.0.1',9898))
    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

l老师，我这个报错是因为什么呢？

#未使用线程同步和互斥锁的情况
from threading import Thread
from time import sleep

class Account:
    def __init__(self,money,name):
        self.money=money
        self.name=name

#模拟提款的操作
class Drawing(Thread):#继承Thread类
    def __init__(self,drawingNum,account):
        Thread.__init__(self)#包含调用父类构造函数
        self.drawingNum=drawingNum
        self.account=account
        self.expenseTotal=0
    def run(self):
        if self.account.money < self.drawingNum:
            return                            #结束函数
        sleep(1)#判断完可以取钱，则阻塞，就是为了测试发生冲突问题
        self.account.money-=self.drawingNum
        self.expenseTotal+=self.drawingNum
        print(f"账户：{self.account.name}，余额是：{self.account.money}")
        print(f"账户：{self.account.name},总共取了：{self.expenseTotal}")

if __name__ == '__main__':
    a1=Account(100,"gaoqi")#实例化对象
    draw1=Drawing(80,a1)#实例化对象，并将a1作为参数传入
    draw2=Drawing(80,a1)
    draw1.start()
    draw2.start()

老师，这里最终为什么总共不是取了160？draw1和draw2传入的第二个参数是同一个对象a1，是不是因为执行draw2线程时又把self.expenseTotal=0重定义了，所以还是一共取了80？

from threading import Thread
from time import sleep

class myshread(Thread):                  #不再是普通的类，要继承类
        def __init__(self,name):
                Thread.__init__(self)
                self.name=name

        def run(self):#  注意必须使用run方法，一个字母错了都不行
                print(f"threading{self.name}start")
                sleep(3)

#创建线程
t1=myshread("t1")
t2=myshread("t2")

#调用类方法
t1.run()
t2.run()

老师，为什么在我的电脑上是等待了一会才出现的第二句而不是同时出现的呢

为什么运行结束后图片不支持打开。。。。，

线程池：pool.map(fun,(arg,arg,arg...))

 如果方法有两个参数怎么传参数进去创建

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 multiprocessing import process
from multiprocessing import Process
from time import sleep
import os

class MyProcess(Process):
    def __init__(self,name):
        self.name=name
        #线程的类包装也有这个过程
        Process.__init__(self)
    
    def run(self):
        print(f"{self.name}开始...")
        sleep(2)
        print(f"{self.name}结束...")

if __name__=="__main__":
    #主进程
    print("当前进程号：{0}".format(os.getpid()))
    #该程序的父类进程
    p1=MyProcess("p1")
    p2=MyProcess("p2")
    p1.start()
    p2.start()

我的输出是这样的：

当前进程号：12352
MyProcess-1开始...
MyProcess-2开始...
MyProcess-1结束...
MyProcess-2结束...

为啥不是p1开始...?

multiprocessing Process,current_process
multiprocessing Manager


(,m_list,m_dict):
    m_dict[] = m_list.append()
__name__ == :
    Manager() mgr:
        m_list=mgr.list()
        m_dict=mgr.dict()
        m_list.append()
        p1=Process(=f,=(,m_dict,m_list))
        p1.start()
        p1.join()

        (m_list)
        (m_dict

老师，我知道哪里出错了，可是怎么改呢，明明和视频一样的代码，它可以运行，我的却出错