Python: threading.Lock threading.RLock
作者：互联网
10个工人生产100个杯子
import time, logging, threading, datetime
FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
cups = []
def vagary(task=100):
while True:
n = len(cups)
logging.info(f'{threading.current_thread()} number: {n}')
if n >= task:
break
cups.append(5)
logging.warning(f'{threading.current_thread()} produce {n + 1}')
for b in range(10):
threading.Thread(target=vagary, name=f'vagary-{b}', args=(100,)).start()
import time, logging, threading, datetime
FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
cups = []
lock = threading.Lock()
def vagary(lock: threading.Lock, task=100):
while True:
lock.acquire(blocking=True)
n = len(cups)
logging.info(f'{threading.current_thread()} number: {n}')
if n >= task:
lock.release()
break
cups.append(5)
logging.warning(f'{threading.current_thread()} produce {n + 1}')
lock.release()
for b in range(10):
threading.Thread(target=vagary, name=f'vagary-{b}', args=(lock, 100)).start()
import time, logging, threading, datetime
FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
class Counter:
def __init__(self):
self.__value = 0
self.lock = threading.Lock()
def increment(self):
# self.lock.acquire(blocking=True)
self.__value += 1
# self.lock.release()
def decrement(self):
# self.lock.acquire(blocking=True)
self.__value -= 1
# self.lock.release()
@property
def value(self):
return self.__value
def do(c: Counter, lock: threading.Lock, count=100):
for _ in range(count):
for i in range(-50, 50):
lock.acquire()
if i < 0:
c.decrement()
else:
c.increment()
lock.release()
c = Counter()
lock = threading.Lock()
for i in range(10):
t = threading.Thread(target=do, args=(c, lock, 10000)) # 此数值给高,否则线程瞬间结束
t.start()
# t.join() # 主线程会等待t结束,再开启下个线程
while True:
time.sleep(1)
print(threading.enumerate())
print(c.value)
import time, logging, threading, datetime
FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(level=logging.INFO, format=FORMAT)
class Counter:
def __init__(self):
self.__value = 0
self.__lock = threading.Lock()
@property
def value(self):
with self.__lock:
return self.__value
def increase(self):
try:
self.__lock.acquire(blocking=True)
self.__value += 1
finally:
self.__lock.release()
def decrease(self):
# try:
# self.__lock.acquire(blocking=True)
# self.__value -= 1
# finally:
# self.__lock.release()
with self.__lock:
self.__value -= 1
def run(c: Counter, count=100):
for _ in range(count):
for i in range(-50, 50):
if i < 0:
c.decrease()
else:
c.increase()
c = Counter()
for b in range(10):
threading.Thread(name=f'Thread--{b}', target=run, args=(c, 10000)).start()
while True:
time.sleep(1)
if threading.active_count() == 1:
print(threading.enumerate())
logging.warning(f'end {c.value}')
break # 结束主进程
else:
print(threading.enumerate())
logging.info(f'progress {c.value}')
import threading, time
lock = threading.Lock()
def w():
time.sleep(3)
lock.release()
lock.acquire()
print(lock.locked())
threading.Thread(target=w).start()
lock.acquire()
print('get lock')
lock.release()
print('release')
print(lock.locked())
****** 如果一个线程 lock.acquire()成功后, 结束 则不会自动lock.release()
import threading, time
lock = threading.Lock()
def b(lock: threading.Lock):
lock.acquire()
time.sleep(2)
print(threading.current_thread(), 'exit 555555')
# lock.release()
def p(lock: threading.Lock):
while True:
time.sleep(1)
if lock.acquire():
print('lock.acquire success')
break
print('lock.acquire failed')
threading.Thread(args=(lock,), target=b, name='bb').start()
threading.Thread(args=(lock,), target=p, name='pp').start()
threading.Timer(interval=6, function=lambda lock: lock.release(), args=(lock,)).start()
while True:
print(threading.enumerate())
time.sleep(0.7)
非阻塞锁:
import threading, time, logging
FORMAT = '%(asctime)-20s [%(threadName)10s, %(thread)8d] %(message)s'
logging.basicConfig(format=FORMAT, level=logging.WARNING)
def vagary(vails):
for vail in vails:
time.sleep(0.001)
if vail.lock.acquire(blocking=False): # 获取锁, 返回True
logging.warning('{} {} acquire success'.format(threading.current_thread(), vail.name))
# 不释放锁
else:
logging.error(f'{threading.current_thread()} {vail.name} acquire failed')
class Vail:
def __init__(self, name):
self.name = name
self.lock = threading.Lock()
vails = [Vail(f'vail-{i}') for i in range(10)]
# 10个vail, 每个vail, 5个线程只有一个获取成功
for i in range(5): # 启动五个线程
threading.Thread(name=f'Thread-{i}', target=vagary, args=(vails,)).start()
Reentrant Lock threading.RLock
一个线程内可acquire多次, 必须全部释放完毕 ,其他线程才可acquire, 必须在自己线程内释放
import threading
import time
lock = threading.RLock()
print(lock, type(lock))
print(lock.acquire())
print(lock.acquire())
print(lock, threading.current_thread())
print(lock.acquire())
def sub(rlock: threading.RLock):
print('in sub', rlock, threading.current_thread())
rlock.acquire()
print('in sub', rlock, threading.current_thread())
rlock.release()
threading.Thread(target=sub, args=(lock,)).start()
# 不能使用Timer, 必须在主线程内release
# threading.Timer(interval=5, function=lambda lock: [lock.release()] * 3, args=(lock,)).start()
time.sleep(5)
lock.release()
lock.release()
lock.release()
标签：logging,Python,lock,self,acquire,RLock,threading,release 来源： https://www.cnblogs.com/dissipate/p/15935549.html