Python线程中同步锁详解

转载: 

https://www.jb51.net/article/139008.htm

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

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

1. Lock(互斥锁,普通锁threading.Lock)

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

Lock(指令锁)是可用的最低级的同步指令.Lock处于锁定状态时,不被特定的线程拥有.Lock包含两种状态---锁定和非锁定,以及两个基本方法.可以认为Lock有一个锁定池,当线程请求锁定时,将线程至于池中,直到获得锁定后出池.

构造方法: Lock()

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

if mutex.acquire():
    counter += 1
    print('I am {}, set counter:{}'.format(self.name, counter))
    mutex.release()

 

2. RLock重入锁(递归锁,threading.Rlock)

RLock(可重入锁)是一个可以被同一个线程请求多次的同步指令.RLock使用了'拥有的线程'和'递归等级'的概念,处于锁定状态时,RLock被某个线程拥有.重入锁使用条件:必须在同一线程内,连续调用多次acquire,一定要注意acquire和release的次数相等.可以认为RLock包含一个锁定池和一个初始值为0的计数器,每次成功调用acquire()/release(),计数器将+1/-1,为0时锁处于未锁定状态.

构造方法: RLock()

实例方法: acquire([timeout])/release(): 跟Lock差不多

3. Semaphore(共享对象访问)

Semaphore管理一个内置的计数器， 每当调用acquire()时内置计数器-1； 调用release() 时内置计数器+1； 
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

直接上代码，我们把semaphore控制为3，也就是说，同时有3个线程可以用这个锁，剩下的线程也之只能是阻塞等待了…

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()

# 结果
I am Thread-1,I will sleep ...
I am Thread-2,I will sleep ...
I am Thread-3,I will sleep ...
main thread sleep 3 seconds... 
I am Thread-1, I awake...
I am Thread-2, I awake...
I am Thread-3, I awake...

5、Condition(线程同步)

Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。

可以把Condition理解为一把高级的锁，它提供了比Lock, RLock更高级的功能，允许我们能够控制复杂的线程同步问题。threading.Condition在内部维护一个锁对象（默认是RLock），可以在创建Condigtion对象的时候把锁对象作为参数传入。Condition也提供了acquire, release方法，其含义与琐的acquire, release方法一致，其实它只是简单的调用内部锁对象的对应的方法而已。Condition还提供了如下方法(特别要注意：这些方法只有在占用锁(acquire)之后才能调用，否则将会报RuntimeError异常。

Condition.wait([timeout]): 

wait方法释放内部所占用的锁，同时线程被挂起，直至接收到通知被唤醒或超时（如果提供了timeout参数的话）。当线程被唤醒并重新占有锁的时候，程序才会继续执行下去。

Condition.notify(): 

唤醒一个挂起的线程（如果存在挂起的线程）。注意：notify()方法不会释放所占用的锁。

Condition.notify_all()

唤醒所有挂起的线程（如果存在挂起的线程）。注意：这些方法不会释放所占用的锁。

对于Condition有个例子，大家可以观摩下。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 协程的详细用法使用和例子
• 实例讲解python中的协程
• 在python里协程使用同步锁Lock的实例