python线程中同步锁详解

2023-09-13 15:36:05 158

在使用多线程的应用下，如何保证线程安全，以及线程之间的同步，或者访问共享变量等问题是十分棘手的问题，也是使用多线程下面临的问题，如果处理不好，会带来较严重的后果，使用python多线程中提供LockRlockSemaphoreEventCondition用来保证线程之间的同步，后者保证访问共享变量的互斥问题

Lock&RLock:互斥锁用来保证多线程访问共享变量的问题
Semaphore对象：Lock互斥锁的加强版，可以被多个线程同时拥有，而Lock只能被某一个线程同时拥有。
Event对象:它是线程间通信的方式，相当于信号，一个线程可以给另外一个线程发送信号后让其执行操作。
Condition对象：其可以在某些事件触发或者达到特定的条件后才处理数据

1、Lock(互斥锁)

请求锁定—进入锁定池等待—获取锁—已锁定—释放锁

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

构造方法：
Lock()

实例方法：
acquire([timeout]):使线程进入同步阻塞状态，尝试获得锁定。
release():释放锁。使用前线程必须已获得锁定，否则将抛出异常。

ifmutex.acquire():
counter+=1
print"Iam%s,setcounter:%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
#blogxiaorui.cc
importtime
importthreading

semaphore=threading.Semaphore(3)

deffunc():
ifsemaphore.acquire():
foriinrange(3):
time.sleep(1)
print(threading.currentThread().getName()+'获取锁')
semaphore.release()
print(threading.currentThread().getName()+'释放锁')


foriinrange(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()函数理解返回。

importthreading
importtime

classMyThread(threading.Thread):
def__init__(self,signal):
threading.Thread.__init__(self)
self.singal=signal

defrun(self):
print"Iam%s,Iwillsleep..."%self.name
self.singal.wait()
print"Iam%s,Iawake..."%self.name

if__name__=="__main__":
singal=threading.Event()
fortinrange(0,3):
thread=MyThread(singal)
thread.start()

print"mainthreadsleep3seconds..."
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有个例子，大家可以观摩下。

fromthreadingimportThread,Condition
importtime
importrandom

queue=[]
MAX_NUM=10
condition=Condition()

classProducerThread(Thread):
defrun(self):
nums=range(5)
globalqueue
whileTrue:
condition.acquire()
iflen(queue)==MAX_NUM:
print"Queuefull,produceriswaiting"
condition.wait()
print"Spaceinqueue,Consumernotifiedtheproducer"
num=random.choice(nums)
queue.append(num)
print"Produced",num
condition.notify()
condition.release()
time.sleep(random.random())


classConsumerThread(Thread):
defrun(self):
globalqueue
whileTrue:
condition.acquire()
ifnotqueue:
print"Nothinginqueue,consumeriswaiting"
condition.wait()
print"Produceraddedsomethingtoqueueandnotifiedtheconsumer"
num=queue.pop(0)
print"Consumed",num
condition.notify()
condition.release()
time.sleep(random.random())


ProducerThread().start()
ConsumerThread().start()

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

python线程中同步锁详解

热门推荐

随机推荐