Python从门到精通(六):线程-04-锁

一、加锁

1.1、Lock

import threading

class SharedCounter:
'''
A counter object that can be shared by multiple threads.
'''
def __init__(self, initial_value = 0):
self._value = initial_value
self._value_lock = threading.Lock()

def inc_r(self,delta=1):
'''
Increment the counter with locking
'''
with self._value_lock:
self._value += delta

def dec_r(self,delta=1):
'''
Decrement the counter with locking
'''
with self._value_lock:
self._value -= delta

1.2、显示锁

import threading

class SharedCounter:
'''
A counter object that can be shared by multiple threads.
'''
def __init__(self, initial_value = 0):
self._value = initial_value
self._value_lock = threading.Lock()

def inc_r(self,delta=1):
'''
Increment the counter with locking
'''
self._value_lock.acquire()
self._value += delta
self._value_lock.release()

def dec_r(self,delta=1):
'''
Decrement the counter with locking
'''
self._value_lock.acquire()
self._value -= delta
self._value_lock.release()

1.3、可重入锁

import threading

class SharedCounter:
'''
A counter object that can be shared by multiple threads.
'''
_lock = threading.RLock()
def __init__(self, initial_value = 0):
self._value = initial_value

def inc_r(self,delta=1):
'''
Increment the counter with locking
'''
with SharedCounter._lock:
self._value += delta

def dec_r(self,delta=1):
'''
Decrement the counter with locking
'''
with SharedCounter._lock:
self.inc_r(-delta)

1.4、并发锁

from threading import Semaphore
import urllib.request

# At most, five threads allowed to run at once
_fetch_url_sema = Semaphore(5)

def fetch_url(url):
with _fetch_url_sema:
return urllib.request.urlopen(url)

二、死锁

2.1、上下文管理器

import threading
from contextlib import contextmanager

_local = threading.local()

@contextmanager
def acquire(*locks):
# Sort locks by object identifier
locks = sorted(locks, key=lambda x: id(x))

# Make sure lock order of previously acquired locks is not violated
acquired = getattr(_local,'acquired',[])
if acquired and max(id(lock) for lock in acquired) >= id(locks[0]):
raise RuntimeError('Lock Order Violation')

# Acquire all of the locks
acquired.extend(locks)
_local.acquired = acquired

try:
for lock in locks:
lock.acquire()
yield
finally:
# Release locks in reverse order of acquisition
for lock in reversed(locks):
lock.release()
del acquired[-len(locks):]

2.2、申请锁

import threading
from chapter12.avoid_lock_1 import acquire

x_lock = threading.Lock()
y_lock = threading.Lock()

def thread_1():
while True:
with acquire(x_lock, y_lock):
print('Thread-1')

def thread_2():
while True:
with acquire(y_lock, x_lock):
print('Thread-2')

t1 = threading.Thread(target=thread_1)
t1.daemon = True
t1.start()

t2 = threading.Thread(target=thread_2)
t2.daemon = True
t2.start()

2.3、TLS检测锁

import threading
from chapter12.avoid_lock_1 import acquire

x_lock = threading.Lock()
y_lock = threading.Lock()

def thread_1():

while True:
with acquire(x_lock):
with acquire(y_lock):
print('Thread-1')

def thread_2():
while True:
with acquire(y_lock):
with acquire(x_lock):
print('Thread-2')

t1 = threading.Thread(target=thread_1)
t1.daemon = True
t1.start()

t2 = threading.Thread(target=thread_2)
t2.daemon = True
t2.start()import threading
from chapter12.avoid_lock_1 import acquire

# The philosopher thread
def philosopher(left, right):
while True:
with acquire(left,right):
print(f'{threading.currentThread()} eating')

# The chopsticks (represented by locks)
NSTICKS = 5
chopsticks = [threading.Lock() for n in range(NSTICKS)]

# Create all of the philosophers
for n in range(NSTICKS):
t = threading.Thread(target=philosopher,
args=(chopsticks[n],chopsticks[(n+1) % NSTICKS]))
t.start()