Python多线程之“锁机制”

锁（Lock）机制简述

锁这个字已经顾名思义了。有A和B两个线程，A和B中的程序都加了同一个锁对象，当线程A率先执行到lock.acquire(),线程B只能在A释放锁lock.release()后才能运行自身的lock.acquire()。

锁（Lock）机制使用

以下代码为如何获取锁，释放锁，获取锁lock.acquire()和释放锁lock.release()必须成对出现，否则会出现死锁的现象。

import threading
#生成全局唯一锁对象
lock = threading.Lock()
#获取锁，未获取到锁会阻塞程序，直至获取到锁才会往下执行
lock.acquire()
#释放锁，其他线程便可以获取该锁
lock.release()

很多时候会忘记释放锁，所以使用上下文管理器来加锁，with语句会在这个代码块执行前自动获取锁，在执行后自动释放锁。

import threading
lock = threading.Lock()
with lock:
#代码块
	pass

为什么要使用锁？

不用锁锁时的多线程。

import threading

def current():
	global n1
	n1 = 0
	for i in range(10):
		n1+=1
		print("current",n1)
def last():
	global n2
	n2 = 0
	for i in range(10):
		n2+=10
		print("last",n2)
if __name__ == "__main__":
	t1 = threading.Thread(target = current)
	t1.start()
	t2 = threading.Thread(target = last)
	t2.start()

看看不使用锁时候的运行结果：

current 1
current 2
current 3
last 10
current 4
current 5
last 20
current 6
last 30
last 40
current 7
current 8
current 9
last 50
last 60
current 10
last 70
last 80
last 90
last 100

两个线程是交替执行的，还是一种串行机制，不加锁输出会很混乱。

加了锁的多线程。

import threading

def current():
	global n1
	n1 = 0
	lock.acquire()
	for i in range(10):
		n1+=1
		print("current",n1)
	lock.release()
def last():
	global n2
	n2 = 0
	lock.acquire()
	for i in range(10):
		n2+=10
		print("last",n2)
	lock.release()
if __name__ == "__main__":
	lock = threading.Lock()
	t1 = threading.Thread(target = current)
	t1.start()
	t2 = threading.Thread(target = last)
	t2.start()

运行结果：

current 1
current 2
current 3
current 4
current 5
current 6
current 7
current 8
current 9
current 10
last 10
last 20
last 30
last 40
last 50
last 60
last 70
last 80
last 90
last 100

进程t1运行完之后才会运行进程t2，这个结果才是我们想要的运行结果，是不是有些道理233.