这篇文章主要为大家详细介绍了python线程中同步锁的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
在使用多线程的应用下，如何保证线程安全，以及线程之间的同步，或者访问共享变量等问题是十分棘手的问题，也是使用多线程下面临的问题，如果处理不好，会带来较严重的后果，使用python多线程中提供lock rlock semaphore event condition 用来保证线程之间的同步，后者保证访问共享变量的互斥问题
lock & rlock:互斥锁 用来保证多线程访问共享变量的问题
semaphore对象：lock互斥锁的加强版，可以被多个线程同时拥有，而lock只能被某一个线程同时拥有。
event对象: 它是线程间通信的方式，相当于信号，一个线程可以给另外一个线程发送信号后让其执行操作。
condition对象：其可以在某些事件触发或者达到特定的条件后才处理数据
1、lock(互斥锁)
请求锁定 — 进入锁定池等待 — 获取锁 — 已锁定 — 释放锁
lock（指令锁）是可用的最低级的同步指令。lock处于锁定状态时，不被特定的线程拥有。lock包含两种状态——锁定和非锁定，以及两个基本的方法。
可以认为lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。
构造方法：
lock()
实例方法：
acquire([timeout]): 使线程进入同步阻塞状态，尝试获得锁定。
release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。
if mutex.acquire():
counter += 1
print "i am %s, set counter:%s" % (self.name, counter)
mutex.release()
2、rlock(可重入锁)
rlock（可重入锁）是一个可以被同一个线程请求多次的同步指令。rlock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，rlock被某个线程拥有。拥有rlock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。
可以认为rlock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。
构造方法：
rlock()
实例方法：
acquire([timeout])/release(): 跟lock差不多。
3、semaphore(共享对象访问)
咱们再聊聊semaphore ，说实话semaphore是我最晚使用的同步锁，以前类似的实现，是我用rlock实现的，相对来说有些绕，毕竟rlock 是需要成对的锁定和开锁的》。。。
semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。
直接上代码，我们把semaphore控制为3，也就是说，同时有3个线程可以用这个锁，剩下的线程也之只能是阻塞等待了…
#coding:utf-8
#blog xiaorui.cc
import time
import threading
semaphore = threading.semaphore(3)
def func():
if semaphore.acquire():
for i in range(3):
time.sleep(1)
print (threading.currentthread().getname() + '获取锁')
semaphore.release()
print (threading.currentthread().getname() + ' 释放锁')
for i in range(5):
t1 = threading.thread(target=func)
t1.start()
4、event(线程间通信)
event内部包含了一个标志位，初始的时候为false。
可以使用使用set()来将其设置为true；
或者使用clear()将其从新设置为false；
可以使用is_set()来检查标志位的状态；
另一个最重要的函数就是wait(timeout=none)，用来阻塞当前线程，直到event的内部标志位被设置为true或者timeout超时。如果内部标志位为true则wait()函数理解返回。
import threading
import time
class mythread(threading.thread):
def __init__(self, signal):
threading.thread.__init__(self)
self.singal = signal
def run(self):
print "i am %s,i will sleep ..."%self.name
self.singal.wait()
print "i am %s, i awake..." %self.name
if __name__ == "__main__":
singal = threading.event()
for t in range(0, 3):
thread = mythread(singal)
thread.start()
print "main thread sleep 3 seconds... "
time.sleep(3)
singal.set()
5、condition(线程同步)
可以把condition理解为一把高级的琐，它提供了比lock, rlock更高级的功能，允许我们能够控制复杂的线程同步问题。threadiong.condition在内部维护一个琐对象（默认是rlock），可以在创建condigtion对象的时候把琐对象作为参数传入。condition也提供了acquire, release方法，其含义与琐的acquire, release方法一致，其实它只是简单的调用内部琐对象的对应的方法而已。condition还提供了如下方法(特别要注意：这些方法只有在占用琐(acquire)之后才能调用，否则将会报runtimeerror异常。)：
condition.wait([timeout]):
wait方法释放内部所占用的琐，同时线程被挂起，直至接收到通知被唤醒或超时（如果提供了timeout参数的话）。当线程被唤醒并重新占有琐的时候，程序才会继续执行下去。
condition.notify():
唤醒一个挂起的线程（如果存在挂起的线程）。注意：notify()方法不会释放所占用的琐。
condition.notify_all()
condition.notifyall()
唤醒所有挂起的线程（如果存在挂起的线程）。注意：这些方法不会释放所占用的琐。
对于condition有个例子，大家可以观摩下。
from threading import thread, condition
import time
import random
queue = []
max_num = 10
condition = condition()
class producerthread(thread):
def run(self):
nums = range(5)
global queue
while true:
condition.acquire()
if len(queue) == max_num:
print "queue full, producer is waiting"
condition.wait()
print "space in queue, consumer notified the producer"
num = random.choice(nums)
queue.append(num)
print "produced", num
condition.notify()
condition.release()
time.sleep(random.random())
class consumerthread(thread):
def run(self):
global queue
while true:
condition.acquire()
if not queue:
print "nothing in queue, consumer is waiting"
condition.wait()
print "producer added something to queue and notified the consumer"
num = queue.pop(0)
print "consumed", num
condition.notify()
condition.release()
time.sleep(random.random())
producerthread().start()
consumerthread().start()
相关推荐：
python多线程之事件event的使用详解
python线程池threadpool的实现
以上就是python线程中同步锁详解的详细内容。