关于Threading中Lock的理解

关于Threading中Lock的理解

Lock的做用

刚开始接触python，对于线程中的锁不是很理解，错误的把Lock实现的效果看成Lock的做用。

• Lock的效果是保证同一时间只有一个线程操做公共资源（全局变量），好比互斥锁，多个线程同时加同一个锁，只有该锁释放时，其余线程才能获取该锁。至于哪一个线程先获取该锁是无序的，以下。
• Lock的做用和效果不一样，经过其不一样的用法最终实现不一样的效果。
  1. 锁对象（Lock）具备获取和释放两种状态，建立时处于释放状态。
  2. 默认建立的Lock具备阻塞做用，当Lock为一线程获取后，其余线程（包括其自身）若获取该锁，则线程阻止，不能往下运行，直到该锁释放。
  3. 若其余线程（包括自身）不获取该锁，则不发生阻塞做用，即阻塞做用发生在线程获取处于锁定状态的锁。
  4. 线程获取后的锁不必定必须释放，但若不释放，其余线程获取该锁时则发生死锁，程序假死。

互斥锁

两个线程使用同一个锁，只有一个线程运行结束后，另外一个线程才能运行。

import threading
import time

total = 0
mutex = threading.Lock()


def sum_num(num):
    mutex.acquire() #获取锁
    for i in range(num):
        global total
        total += 1
    print(f'{threading.current_thread()}sum num is: {total}.')
    mutex.release() #释放锁

if __name__ == '__main__':
    thread_list = []
    for num in [1000000 for i in range(10)]:
        multi_thread = threading.Thread(target=sum_num,args=(num,),)
        multi_thread.start()
        thread_list.append(multi_thread)

    # 主线程等待子线程运行结束后运行打印
    for t in thread_list:
        t.join()
    print('total is:', total)

示例

建立两个线程，其中一个线程输出1-52，另一个输出A-Z，要求输出的格式以下：

12A 34B 56C ..... 5152Z

使用一个锁

import threading, time

def num():
    for i in range(1,53,2):
        lock.acquire()
        print(str(i)+str(i+1), end='')

def alpha():
    for i in range(65, 91):
        time.sleep(0.000001)
        print(chr(i))
        lock.release()

if __name__ == '__main__':
    lock = threading.Lock()

    sn = threading.Thread(target=num)
    sa = threading.Thread(target=alpha)

    sn.start()
    sa.start()

使用多个锁

import threading, time
alpha_lock = threading.Lock()
num_lock = threading.Lock()

def print_num():
    num_lock.acquire() #先加锁，当输出2本身在获取锁时必须等待另外一进程释放
    for i in range(1, 53, 2):

        print(str(i)+str(i + 1), end='')

        num_lock.acquire()
        alpha_lock.release()

def print_alpla():

    for w in range(ord('A'), ord('Z') + 1,):

        print(chr(w))

        num_lock.release()
        alpha_lock.acquire()


if __name__ == '__main__':
    num_thread = threading.Thread(target=print_num,)
    alpha_thread = threading.Thread(target=print_alpla)

    alpha_lock.acquire()
    num_thread.start()
    alpha_thread.start()

重点是进程再次获取本身已经获取到的锁时必须等待另外一进程释放

收获

• 遇到不懂的问题除了谷歌外，多看python文档，极可能是本身理解不到位。