多线程锁,线程池,消费者生产者模型

锁是怎么存在的?

在python建立之初,开发者目的是为了快速把语言开发出来,如果加上GIL(c语言加锁),切换时按照100条字节指令来进行线程间的切换

为什么加锁?

非线程安全,控制一段代码

1.lock = threading.BoundedSemaphore
一次可以限制关卡,限制通行次数,不过这个是写死的

import time
import threading
lock = threading.BoundedSemaphore(3)#一次放三个(一次只通行三个)
def func(arg):
    lock.acquire()
    time.sleep(1)
    print(arg)
    lock.release()
for i in range(20):
    t = threading.Thread(target=func, args=(i,))
    t.start()

2.

lock = threading.Condition()

一次可以限制关卡,限制通行次数,不过这个是写活的

可以自定义加载个数 ,只需在后面便利后加一个参数

lock.notify(inp) inp 来限制次数

lock = threading.Condition()
def func(arg):
    print('线程进来了')
    lock.acquire()
    lock.wait() # 加锁这个特殊需要等待参数传递
    print(arg)
    time.sleep(1)
    lock.release()
for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()
while True:
    inp = int(input('>>>'))
    lock.acquire()
    lock.notify(inp)#加的控制次数的 这个是特殊的
    lock.release()

3.

lock = threading.Event()  获取全部
注意.获取全部使用   lock.wait() 加锁的

input(">>>>") 是用来控制是否全部获取的一个开关,一旦输入 ,解锁会获取全部  后面需要加入 lock.set() 绿灯
如果想再次使用这个函数, lock.clear() 重新清空

import time
import threading

lock = threading.Event()

def func(arg):
    print('线程来了')
    lock.wait() # 加锁：红灯
    print(arg)
for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()
input(">>>>")
lock.set() # 绿灯
lock.clear() # 再次变红灯
for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()
input(">>>>")
lock.set()

4.

 v = threading.local()#内部创建一个属于自己的值 phone=arg 为了区分自己拿的包

import time
import threading
v = threading.local()
def func(arg):
    # 内部会为当前线程创建一个空间用于存储：phone=自己的值
    v.phone = arg
    time.sleep(2)
    print(v.phone,arg) # 去当前线程自己空间取值
for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

线程池: 用来约束每次输出的次数,不是全部哪出啊,可以限制一次拿出几个

from concurrent.futures import ThreadPoolExecutor
import  time
def func(a1,a2):
    time.sleep(5)
    print(a1,a2)
a=ThreadPoolExecutor(4)#实例化对象让其限制次数 
for i  in  range(40):
    a.submit(func,i,15)

生产者,消费者模型

这种模型在多线程中属于按顺序使用  现有生产才有消费,这个是一个固定顺序,而在函数中,为了更明确这种概念而不考虑生产时间限制

来更符合逻辑性 出现了queue 模块  首先实例化对象  q=queue.Queue 在用方法q.put(" ") 括号里面必须有字符串提示从这里入,符合队列(先进先出)而抛开逻辑

后面用q.get( ) 方法提示出来了

import time
import threading
import queue
q=queue.Queue()#实例化对象
def mk(id):
    while 1:
        time.sleep(3)
        q.put("布加迪")#首先进入q.put
        print("师傅%s 生产了一个布加迪"% id)
for i  in  range(1,3):
    t=threading.Thread(target=mk,args=(i,))
    t.start()
def et(id):
    while 1:
        time.sleep(1)
        v1=q.get()#然后冲进去
        print("连达%s 吃了一个布加迪"% id)
for i  in  range(1,6):
    t1=threading.Thread(target=et,args=(i,))
    t1.start()