一、Lock锁
- 凡是存在共享资源争抢的地方都可以使用锁,从而保证只有一个使用者可以完全使用这个资源一旦线程获得锁,其他试图获取锁的线程将被阻塞
- acquire(blocking=True,timeout=-1): 默认阻塞,阻塞可以设置超时时间,非阻塞时,timeout禁止设置,成功获取锁,返回True,否则返回False
- releas() : 释放锁,可以从任何线程调用释放,已上锁的锁,会被重置为unlocked未上锁的锁上调用,抛出RuntimeError异常
例如:
订单要求生成1000个杯子,组织10个工人生产
举例1:
import threading
from threading import Thread, Lock
import time
import logging
FORAMT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(format=FORAMT, level=logging.INFO)
cups = []
def worker(count=10):
logging.info("I'm working for u")
flag = False
while True:
if len(cups) >= count:
flag = True
time.sleep(0.001) # 为了看出现场切换效果
if not flag:
cups.append(1)
if flag:
break
logging.info("{} finished.cups= {}".format(threading.current_thread().name, len(cups)))
for _ in range(10): # 开启10个线程
Thread(target=worker, args=(1000,)).start()
从上例的运行结果看出,多线程调度,导致了判断失效,多生成了杯子
如何修改,加锁
举例2:
import threading
from threading import Thread, Lock
import time
import logging
FORAMT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(format=FORAMT, level=logging.INFO)
cups = []
lock = Lock()
def worker(count=10):
logging.info("I'm working for u")
flag = False
while True:
lock.acquire()
if len(cups) >= count:
flag = True
#lock.release() # 这里释放锁合适吗?
time.sleep(0.001) # 为了看出现场切换效果
if not flag:
cups.append(1)
lock.release() # 这里释放锁对不对
if flag:
break
logging.info("{} finished.cups= {}".format(threading.current_thread().name, len(cups)))
for _ in range(10): # 开启10个线程
Thread(target=worker, args=(1000,)).start()
假设第一句lock.release()合适,分析如下:
有一个时刻len(cups),正好是999,flag=True,释放锁,线程被打断,另一个线程判断发现是
999,flag=True,可能线程被打断,可能另一个线程判断也是999,flag也设置为True
这三个线程只要继续执行到cups.append(1),一定会导致cups的长度超过1000
假设第二句lock.release()合适,分析如下:
在某一时刻len(cups),正好是999,flag=True,其他线程试图访问这段代码的线程都被阻塞获取
不到锁,直到当前线程安全的增加了一个数据,然后释放锁,其它线程有一个抢到锁,但发现
已经是1000了,只好break打印退出,所有其他线程接着都退出
二、加锁、解锁
- 一般来说加锁后还要一些代码实现,在释放锁之前还有可能抛异常,一旦出现异常所无法释放,但是当前线程可能因为这个异常被终止了,这就产生了死锁
- 加锁、解锁常用语句:
- 使用try...finally语句保证锁的释放
- with上下文管理,锁对象支持上下文管理
import threading
from threading import Thread, Lock
import time
class Counter:
def __init__(self):
self._val = 0
self.__lock = Lock()
@property
def value(self):
with self.__lock:
return self._val
def inc(self):
try:
self.__lock.acquire()
self._val += 1
finally:
self.__lock.release()
def dec(self):
with self.__lock:
self._val -= 1
def run(c:Counter, count=100):
for _ in range(count):
for i in range(-50,50):
if i < 0:
c.dec()
else:
c.inc()
c = Counter()
c1 = 10
c2 = 100
for i in range(c1):
Thread(target=run, args=(c,c2)).start()
while True:
time.sleep(1)
if threading.active_count() == 1:
print(threading.enumerate())
print(c.value)
else:
print(threading.enumerate())
三、锁的应用场景
- 锁适用于访问和修改同一个共享资源的时候,即读写同一个资源的时候,如果全部都是读取同一个共享资源需要锁吗,不需要,因为这时可以认为共享资源是不可变的,每一次读取它都是一样的值,所有不用加锁
- 少用锁,必要时用锁,使用了锁,多线程访问被锁的资源时,就成了串行,要么排队,要么争抢
- 加锁时间越短越好,不需要就立即释放锁
- 一定要避免死锁
1、可重入锁Rlock
- 可重入锁,是线程相关的锁,线程A获得可重复锁,并可以多次成功获取,不会阻塞,最后要在线程A中做和acquire次数相同的relea
import threading
import time
lock = threading.RLock()
print(lock.acquire())
print('-------------------------')
print(lock.acquire(blocking=False))
print(lock.acquire())
print(lock.acquire(timeout=3.55))
print(lock.acquire(blocking=False))
lock.release()
lock.release()
lock.release()
lock.release()
lock.release()
四、Condition
- 构造方法Condition(lock=None),可以传入一个Lock或RLock对象,默认是RLock
- Conditon用于生产者,消费者模型,为了解决生产者消费者速度匹配问题
- acquire(*args) : 获取锁
- wait(self,time=None) : 等待或超市
- notify(n=1) : 唤醒至多指定数目个数的等待线程,没有等待的线程就没有任何操作
- notif_all() : 唤醒所有等待的线程
举例1: 消费者消费速度大于生产者生成速度
from threading import Thread, Lock, Event, Condition
import time, random
import logging
FORAMT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(format=FORAMT, level=logging.INFO)
# 此例只是为了演示,不考虑线程安全问题
class Dispatcher:
def __init__(self):
self.data = None
self.event = Event() #event只是为了使用方便,与逻辑无关
self.cond = Condition()
def produce(self, total):
for _ in range(total):
data = random.randint(0,100)
with self.cond:
logging.info(data)
self.data = data
self.cond.notify_all() # 通知消费者消费,启动所有线程
self.event.wait(1) # 模拟产生数据速度
self.event.set()
def consume(self):
while not self.event.is_set():
with self.cond: # 消费者等待
self.cond.wait()
logging.info("received {}".format(self.data))
self.data = None
self.event.wait(0.5) #模拟消费的速度
d = Dispatcher()
p = Thread(target=d.produce, args=(10,), name='prodcer')
c = Thread(target=d.consume, name='consumer')
c.start()
p.start()
消费者等待数据,如果生产者准备好了会通知消费者消费,省得消费者反复来查看数据是否就绪
Condition用于生产者消费者模型中,解决生产者消费者速度匹配的问题
采用了通知机制,非常有效率
使用方式,使用Condition,必须先acquire,用完了要release,因为内部使用了锁,默认使用了RLock锁,
最好方式是使用with上下文管理
消费者wait,等待通知,生产者生产好消息,对消费者发通知,可以使用notify或者notify_all方法
五、线程同步Barrier
- 有人翻译成栅栏,建设理解成屏障,可以想象成路障,道闸
- Barrier(parties, action=None, timeout=None): 构建Barrier对象,指定参与方数目,timeout是wait方法未指定超时的默认值
- n_waiting : 当前在屏障中等待的线程数
- parties : 各方数,就是需要多少个等待
- wait(timeout=None) : 等待通过屏障,返回0到线程数-1的整数,每个线程返回不同,如果wait方法设置了超时,并超时发送,屏障将处于broken状态
1、Barrier实例
- broken :如果屏障处于打破的状态,返回True
- abort() : 将屏障置于broken状态,等待中的线程或者调用等待方法的线程中都会抛出BrokenBarrierError异常,直到reset方法来恢复屏障
- reset(): 恢复屏障,重新开始拦截
import threading
import logging
#输出格式定义
FORMAT = '%(asctime)-15s\t [%(threadName)s, %(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
def worker(barrier:threading.Barrier):
logging.info('waiting for {} threads'.format(barrier.n_waiting))
try:
barrier_id = barrier.wait()
logging.info('after barrier {}'.format(barrier_id))
except threading.BrokenBarrierError:
logging.info('Broken Barrier')
barrier = threading.Barrier(3) #设置拦截线程数
for x in range(3):
threading.Thread(target=worker, name='worker-{}'.format(x), args=(barrier,)).start()
logging.info('started')
从运行结果看出:
所有线程冲到了Barrier前等待,直到到达parties的数目,屏障打开,所有线程停止等待,继续执行
再有线程wait,屏障就绪等到到达参数方数目
举例 ,赛马比赛所有马匹就位,开闸
举例2:
import threading
import logging
#输出格式定义
FORMAT = '%(asctime)-15s\t [%(threadName)s, %(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
def worker(barrier:threading.Barrier):
logging.info('waiting for {} threads'.format(barrier.n_waiting))
try:
barrier_id = barrier.wait()
logging.info('after barrier {}'.format(barrier_id))
except threading.BrokenBarrierError:
logging.info('Broken Barrier run')
barrier = threading.Barrier(3)
for x in range(0,9):
if x == 2:
barrier.abort()
if x == 6:
barrier.reset()
threading.Event().wait(1)
threading.Thread(target=worker, name='worker-{}'.format(x), args=(barrier,)).start()
logging.info('started')
上例中等待了2个,屏障就被break了,waiting的线程抛了BrokenBarrierError异常
新wait的线程也抛异常,直到屏障恢复,才继续按照parties数目要求继续拦截线程
2、wait方法超时实例
- 如果wait方法超时发生,屏障将处于broken状态,直到reset
import threading
import logging
#输出格式定义
FORMAT = '%(asctime)-15s\t [%(threadName)s, %(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
def worker(barrier:threading.Barrier, i:int):
logging.info('waiting for {} threads'.format(barrier.n_waiting))
try:
logging.info(barrier.broken) # 是否broken
if i < 3:
barrier_id = barrier.wait(1) # 超时后,屏障broken
else:
if i == 6:
barrier.reset() #恢复屏障
barrier_id = barrier.wait(1)
logging.info('after barrier {}'.format(barrier_id))
except threading.BrokenBarrierError:
logging.info('Broken Barrier run')
barrier = threading.Barrier(3)
for x in range(0,9):
threading.Event().wait(2)
threading.Thread(target=worker, name='worker-{}'.format(x), args=(barrier,x)).start()
logging.info('started')
3、Barrier应用
- 所有线程都必须初始化完成,才能继续工作,例如运行前加载数据,检查,如果这些工作没有完成,就开始运行,将不能正常工作
- 10个线程做10种工作准备,每个线程负责一种工作,只有这10个线程都完成后,才能继续工作,先完成的要等待后完成的线程
六、semaphore信号量
- 和Lock很像,信号量对内部维护一个到计数器,每一次acquire都会减1,
- 当acquire方法发现计数为0就阻塞请求的线程,直到其他线程对信号量release后,计数大于0,恢复阻塞线程
- Semaphore(value=1): 构造方法,value小于0,抛出异常ValueError异常
- acquire(blocking=True,time=None) : 获取信号量,计数器减1,获取成功返回True
- release() : 释放信号量,计数器加1
- 计数器永远不会低于0,因为acquire的时候,发现是0,都会被阻塞
import threading
import logging
import time
#输出格式定义
FORMAT = '%(asctime)-15s\t [%(threadName)s, %(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
def worker(barrier:threading.Semaphore):
logging.info('in sub thread')
logging.info(s.acquire())
logging.info('sub thread over')
#信号量
s = threading.Semaphore(3)
logging.info(s.acquire())
logging.info(s.acquire())
logging.info(s.acquire())
threading.Thread(target=worker, args=(s,)).start()
time.sleep(2)
logging.info(s.acquire(False))
logging.info(s.acquire(timeout=3)) #阻塞
#释放
logging.info('released')
s.release()
应用举例:
实现一个简单的连接池,连接池应该有容量,有一个工厂方法可以获取连接,能够被不要的连接返回,供其他调用者使用
import threading
import logging
import random
#输出格式定义
FORMAT = '%(asctime)-15s\t [%(threadName)s, %(thread)8d] %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
class Conn:
def __init__(self, name):
self.name = name
def __repr__(self):
return self.name
class Pool:
def __init__(self, count:int):
self.count = count
#池中是连接对象列表
self.pool = [self._connect("conn-{}".format(x)) for x in range(self.count)]
self.semaphore = threading.Semaphore(count)
def _connect(self, conn_name):
#返回一个名称
return Conn(conn_name)
def get_conn(self):
#从池中拿走一个连接
self.semaphore.acquire()
conn = self.pool.pop()
return conn
def return_conn(self, conn:Conn):
#向池中添加一个连接
self.pool.append(conn)
self.semaphore.release()
# 连接池初始化
pool = Pool(3)
def worker(pool:Pool):
conn = pool.get_conn()
logging.info(conn)
#模拟使用了一段时间
threading.Event().wait(random.randint(1,4))
pool.return_conn(conn)
for i in range(6):
threading.Thread(target=worker, name="worker-{}".format(i), args=(pool,)).start()
上例中,使用信号量解决资源有限的问题
如果池中有资源,请求者获取资源时信号量减1,拿走资源,当请求超过资源数,请求者只能等待,
当使用者用完归还资源后信号量加1,等待线程拿到就可以唤醒拿走资源
1、信号量和锁
- 锁,只允许同一个时间一个线程独占资源,它是特殊的信号量,即信号量计数器初值为1
- 信号量,允许多个线程访问共享资源,但是这个共享资源数量有限
- 锁可以看做是特殊的信号量
2、数据结构和GIL
- Queue :标准库queue模块,提供FIFO的Queue,LIFO的队列,优先队列
- Queue类是线程安全的,适用于多线程间安全的交换数据,内部使用了Lock和Condition
3、GIL全局解释器锁
- Cpython在解释器进程级别有一把锁,叫做GIL全局解释器
- GIL保证CPython进程中,只有一个线程执行字节码,甚至是在多核CPU的情况下,也是如此
- CPython中,IO密集型,由于线程阻塞,就会调度其他线程,CPU密集型,当前线程可能会连续的获得GIL,导致其他线程几乎无法使用CPU