目录
threading.RLock类：
可重入锁，是线程相关的锁；
线程A获得可重复锁，并可多次成功获取，不会阻塞，最后要在线程A中做和acquire次数相同的release（拿多少次锁，还多少回来）；
注，线程相关：
threading.local类；
例：
lock = threading.RLock()
ret = lock.acquire()
print(ret)
ret = lock.acquire(timeout=5)
print(ret)
ret = lock.acquire(False)
print(ret)
ret = lock.acquire(False) #全能拿到锁
print(ret)
lock.release()
lock.release()
lock.release()
lock.release()
# lock.release() #前面没有对应的acquire，抛RuntimeError: cannot release un-acquired lock
def sub(lock:threading.RLock):
lock.release() #主线程中加的，不能在子线程中释放，理解线程级别
threading.Thread(target=sub, args=(lock,)).start()
输出：
True
True
True
True
Exception in thread Thread-1:
Traceback (most recent call last):
File "D:\Python\Python35\lib\threading.py", line 914, in _bootstrap_inner
self.run()
File "D:\Python\Python35\lib\threading.py", line 862, in run
self._target(*self._args, **self._kwargs)
File "E:/git_practice/cmdb/example_threading2.py", line 249, in sub
lock.release()
RuntimeError: cannot release un-acquired lock
threading.Condition类：
Condition(lock=None)，构造方法，可传入一个lock或RLock对象，默认是RLock；
cond = threading.Condition()
cond.acquire(*args)，获取锁；
cond.release()
cond.wait(timeout=None)，等待或超时；
cond.notify(n=1)，唤醒至多指定数目个数的等待线程，默认1个，没有等待的线程就没有任何操作，源码中waiter；
cond.notify_all()，唤醒所有等待的线程，源码中waiters；
总结：
Condition用于生产者-消费者模型，解决生产者-消费者速度匹配问题；
采用了通知机制，非常有效率；
使用Condition，必须先acquire，用完要release，因为内部使用了锁，默认使用RLock，最好的方式是使用with上下文；
消费者wait等待通知，生产者生产好消息，对消费者发通知，可使用notify或notify_all；
可把Condition理解为一把高级的锁，它提供了Lock、RLock更高级的功能，允许我们能够控制复杂的线程同步问题；
threading.Condition内部维护了一个锁对象（默认是RLock），可在创建Condition对象时把锁对象作为参数传入；
threading.Condition也提供了acquire和release方法，含义与锁的一致，其实它只是简单调用内部锁对象的对应的方法而已；
threading.Condition还提供了wait、notify、notify_all方法：
wait([timeout])，释放内部所占用的锁，同时线程被挂起，直至接收到通知被唤醒或超时（如果提供timeout），当线程被唤醒并重新占用锁时，程序才会继续执行下去；
notify()，唤醒一个挂起的线程（如果存在挂起的线程），notify()不会释放所占用的锁；
notify_all()，唤醒所有挂起的线程（如果存在挂起的线程），不会释放所占用的锁；
Lock与RLock：
RLock允许在同一线程中被多次acquire，而Lock不允许这种情况；
如果使用RLock，那么 acquire和release必须成对出现，即调用了n次acquire，必须调用n次release才能真正释放所占用的锁；
例：
class Dispatcher:
def __init__(self):
self.data = 0
self.event = threading.Event()
def produce(self):
for i in range(100):
data = random.randint(1,100)
self.data = data
self.event.wait(1)
def custom(self):
while True: #消费者浪费了大量cpu时间，主动来查看有没有数据
logging.info(self.data) #有重复消费问题
self.event.wait(1) #隔1秒生成1个
d = Dispatcher()
p = threading.Thread(target=d.produce)
c = threading.Thread(target=d.custom)
c.start() #消费者先启动
p.start()
输出：
……
2018-08-06-15:54:25 Thread info: 13052 Thread-1 13
2018-08-06-15:54:25 Thread info: 12052 Thread-2 13
2018-08-06-15:54:26 Thread info: 12052 Thread-2 13
……
例：
class Dispatcher:
def __init__(self):
self.data = 0
self.event = threading.Event()
self.cond = threading.Condition()
def produce(self):
for i in range(100):
data = random.randint(1,100)
# logging.info(data)
with self.cond:
self.data = data
self.cond.notify(2) #通知机制，有数据，通知消费者来消费；交给2个人做，一般是1（生产者）对多（消费者）
self.cond.notify_all() #通知所有消费者，1对多
self.event.wait(1)
def custom(self):
# while True:
while not self.event.is_set():
# logging.info(self.data)
with self.cond: #消费者被迫匹配生产者
self.cond.wait()
logging.info(self.data)
# self.event.wait(1)
d = Dispatcher()
p = threading.Thread(target=d.produce)
# c = threading.Thread(target=d.custom)
# c1 = threading.Thread(target=d.custom) #开启2个消费线程
# c.start()
# c1.start()
for i in range(5): #开启5个消费线程；如果produce中self.conf.notify(2)，生产者通知2个线程处理，5个消费者中谁抢在前谁处理
threading.Thread(target=d.custom, name='c-{}'.format(i)).start()
p.start() #如果生产者先启动，已经生成的数据不会被消费者消费，除非在队列中
注：
以上有线程安全问题，解决：中间加MQ；
上例不是线程安全的，程序逻辑有很多瑕疵，但可很好的理解Condition的使用和生产者消费者模型；
一对多，其实就是广播模式；
threading.Barrier类：
屏障、栅栏，可以想象成路障、道闸，3.2引入；
Barrier(paties,action=None,timeout=None)，构建Barrier对象，指定参与方数目，timeout是wait方法未指定超时的默认值；
n_waiting，当前在屏障中等待的线程数；
paties，参与方数目，需要多少个等待；
wait(timeout=None)，等待通过屏障，返回0到线程数count-1的整数，count为等待的线程总数，每个线程返回不同；如果wait方法设置了超时，并超时发送，屏障将处于broken状态；wait方法超时发生，屏障处于broken状态，直至reset；
broken，如果屏障处于打破的状态，返回True；
abort()，将屏障置于broken状态，等待中的线程或调用等待方法的线程中都会抛BrokenBarrierError异常，直至reset方法来恢复屏障；
reset()，恢复屏障，重新开始拦截；
应用场景：
1、并发初始化；如，centos7中systemd，能并行启动就并行；
所有线程都必须初始化完成后，才能继续工作，如运行前加载数据、检查，如果这些工作没完成就开始运行，将不能正常工作；
10个线程做10种工作准备，只有这10个线程都完成后，才能继续工作，先完成的要等待后完成的线程；
如，启动一个程序，先加载磁盘文件、缓存预热、初始化连接池等，这些工作齐头并进，不过只有等满足了，程序才能继续后向执行，假设数据库连接失败，则初始化工作失效，就要abort，屏障broken，所有线程收到异常退出；
2、工作量，有10个计算任务，完成6个就算工作完成，如求样本数、求平均数；
例：
def worker(barrier:threading.Barrier):
logging.info('n_waiting={}'.format(barrier.n_waiting))
try:
bid = barrier.wait()
logging.info('after barrier {}'.format(bid))
except threading.BrokenBarrierError:
logging.info('broken barrier is {}'.format(threading.current_thread()))
barrier = threading.Barrier(3) #3个一拨3个一拨
for _ in range(3): #依次3,4,5,6
threading.Thread(target=worker,args=(barrier,)).start()
输出：
2018-08-07-08:27:53 Thread info: 11496 Thread-1 n_waiting=0
2018-08-07-08:27:53 Thread info: 12540 Thread-2 n_waiting=1
2018-08-07-08:27:53 Thread info: 4612 Thread-3 n_waiting=2
2018-08-07-08:27:53 Thread info: 4612 Thread-3 after barrier 2
2018-08-07-08:27:53 Thread info: 11496 Thread-1 after barrier 0
2018-08-07-08:27:53 Thread info: 12540 Thread-2 after barrier 1
例：
for i in range(6):
if i == 2: #屏障中等待2个，屏障被broken，wait的线程抛异常，新wait的线程也抛异常，直至屏障恢复，才继续按达到参与方的数目继续拦截
barrier.abort()
elif i == 3:
barrier.reset()
threading.Event().wait(1)
threading.Thread(target=worker,args=(barrier,)).start()
输出：
2018-08-07-09:21:49 Thread info: 12668 Thread-1 n_waiting=0
2018-08-07-09:21:50 Thread info: 12424 Thread-2 n_waiting=1
2018-08-07-09:21:50 Thread info: 12424 Thread-2 broken barrier is <Thread(Thread-2, started 12424)>
2018-08-07-09:21:50 Thread info: 12668 Thread-1 broken barrier is <Thread(Thread-1, started 12668)>
2018-08-07-09:21:51 Thread info: 11468 Thread-3 n_waiting=0
2018-08-07-09:21:51 Thread info: 11468 Thread-3 broken barrier is <Thread(Thread-3, started 11468)>
2018-08-07-09:21:52 Thread info: 9788 Thread-4 n_waiting=0
2018-08-07-09:21:53 Thread info: 12680 Thread-5 n_waiting=1
2018-08-07-09:21:54 Thread info: 10948 Thread-6 n_waiting=2
2018-08-07-09:21:54 Thread info: 10948 Thread-6 after barrier 2
2018-08-07-09:21:54 Thread info: 9788 Thread-4 after barrier 0
2018-08-07-09:21:54 Thread info: 12680 Thread-5 after barrier 1
例：
wait方法超时发生，屏障处于broken状态，直至reset；
def worker(barrier:threading.Barrier, i:int):
logging.info('waiting for {} threads'.format(barrier.n_waiting))
try:
logging.info(barrier.broken)
if i < 3:
barrier_id = barrier.wait(1)
else:
if i == 6:
barrier.reset()
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(9):
threading.Event().wait(2)
threading.Thread(target=worker, args=(barrier,x), name='worker-{}'.format(x)).start()
输出：
2018-08-07-09:33:24 Thread info: 10556 worker-0 waiting for 0 threads
2018-08-07-09:33:24 Thread info: 10556 worker-0 False
2018-08-07-09:33:25 Thread info: 10556 worker-0 broken barrier. run.
2018-08-07-09:33:26 Thread info: 12752 worker-1 waiting for 0 threads
2018-08-07-09:33:26 Thread info: 12752 worker-1 True
2018-08-07-09:33:26 Thread info: 12752 worker-1 broken barrier. run.
2018-08-07-09:33:28 Thread info: 5324 worker-2 waiting for 0 threads
2018-08-07-09:33:28 Thread info: 5324 worker-2 True
2018-08-07-09:33:28 Thread info: 5324 worker-2 broken barrier. run.
2018-08-07-09:33:30 Thread info: 6716 worker-3 waiting for 0 threads
2018-08-07-09:33:30 Thread info: 6716 worker-3 True
2018-08-07-09:33:30 Thread info: 6716 worker-3 broken barrier. run.
2018-08-07-09:33:32 Thread info: 9180 worker-4 waiting for 0 threads
2018-08-07-09:33:32 Thread info: 9180 worker-4 True
2018-08-07-09:33:32 Thread info: 9180 worker-4 broken barrier. run.
2018-08-07-09:33:34 Thread info: 6788 worker-5 waiting for 0 threads
2018-08-07-09:33:34 Thread info: 6788 worker-5 True
2018-08-07-09:33:34 Thread info: 6788 worker-5 broken barrier. run.
2018-08-07-09:33:36 Thread info: 12044 worker-6 waiting for 0 threads
2018-08-07-09:33:36 Thread info: 12044 worker-6 True
2018-08-07-09:33:38 Thread info: 5020 worker-7 waiting for 1 threads
2018-08-07-09:33:38 Thread info: 5020 worker-7 False
2018-08-07-09:33:40 Thread info: 13052 worker-8 waiting for 2 threads
2018-08-07-09:33:40 Thread info: 13052 worker-8 False
2018-08-07-09:33:40 Thread info: 13052 worker-8 after barrier 2
2018-08-07-09:33:40 Thread info: 5020 worker-7 after barrier 1
2018-08-07-09:33:40 Thread info: 12044 worker-6 after barrier 0
