Python——Lock（锁）

锁是为了可能出现的数据不同步或数据不对称问题的解决方法，如果需要大量的用户访问相同数据时，为了数据的一致性和安全。那么就需要加锁。

概念：

锁相当于是将用户访问需求进行队列化，即第一个用户访问时，后续用户无法进行相同数据的访问。直到第一个用户访问完成后，由队列中的第二个用户继续访问。

互斥锁

特点：

1. 两种表现形式，with和acquire，release

2. 在用一个线程中，不能连续acquire多次（进程会卡在这），必须要进行release后才能继续acquire（会报错，RuntimeError: release unlocked lock）

3. 在操作全局变量和+=，-=，*=，/=这类计算在赋值类，或lis[0]+=1,dic['key']-=1这类时，就会出现数据不一致的问题。

4. 线程multiprocessing和Threading都有锁（Lock）这个模块，而且都能达到下面的要求。

from threading     import Thread,Lock
 
a     = 1
def func1(lock):
    with lock:
        for i     in range (    100000 ):
            global a
            a     - = 1
def func2(lock):
    with lock:
        for i     in range (    100000 ):
            global a
            a     + = 1
lock     = Lock()
t1     = Thread(target    = func1,args    = (lock,))
t2     = Thread(target    = func2,args    = (lock,))
t1.start()
t2.start()
t1.join()
t2.join()
print (a)

from Threading     import Lock
lock     = Lock()
lock.acquire()
print (    1 )
lock.acquire()  
print (    2 )
'''
1
'''

死锁现象

就像一个餐桌吃饭，桌子上有一把叉子和一份面，只有两个都拿到的人才能吃面，那么就会出现一个人拿着叉子不松手，一个人端着面不松手。这样就僵在那了。导致的死锁现象。

特点：

1. 一个线程中，存在一把以上的锁。

2. 多把锁交替使用。

解决办法：

1. 使用递归锁（应急使用）

2. 优化代码（完全解决问题使用）

递归锁

特点：

1. 在同一个线程中，可以连续acquire多次，也不会被锁住

2. acquire多少次，就需要release多少次。

3. 占用了更多的资源，但是能够快速解决问题。

4. 递归锁也会发生死锁现象。

5. 使用方式和互斥锁一样。

from threading     import Thread,RLock
 
class SingLeton(    object ):
    instance     = None
    rlock     = RLock()
    def __new__(    cls ,     * args,     * * kwargs):
        with     cls .rlock:
            if not cls .instance:
                cls .instance     = object .__new__(    cls )
        return cls .instance
for i     in range (    10 ):
    print (SingLeton())