Python基础-多线程与Lock锁

多线程

Python的线程是真正的Posix Thread，而不是模拟出来的线程。

Python的标准库提供了两个模块_thread低级模块和threading高级模块（重点）

运行示例

由于任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程，Python的threading模块有个current_thread()函数，它永远返回当前线程的实例。主线程实例的名字叫MainThread，子线程的名字在创建时指定，我们用LoopThread命名子线程。名字仅仅在打印时用来显示，完全没有其他意义，如果不起名字Python就自动给线程命名为Thread-1，Thread-2……

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 多线程

import time, threading

# 新线程的执行的代码
def loop():
print("子线程 %s 开始运行" % threading.current_thread().name)

n = 0
while n < 5:
n = n +1
print("子线程 %s >>> %d " % (threading.current_thread().name, n))
time.sleep(1)

print("子线程 %s 结束运行" % threading.current_thread().name)

def testRun():
# 任何进程默认启动一个线程，且该进程默认称为主进程
print("主线程 %s 开始运行" % threading.current_thread().name)

# 主进程可以启动新的进程，名称可以自己定义，默认Thread-1
t = threading.Thread(target=loop, name = "MyLoopThread")
t.start()
t.join()

print("主线程 %s 结束运行" % threading.current_thread().name)

testRun()

执行结果

D:\PythonProject>python main.py
主线程 MainThread 开始运行
子线程 MyLoopThread 开始运行
子线程 MyLoopThread >>> 1
子线程 MyLoopThread >>> 2
子线程 MyLoopThread >>> 3
子线程 MyLoopThread >>> 4
子线程 MyLoopThread >>> 5
子线程 MyLoopThread 结束运行
主线程 MainThread 结束运行

线程安全锁 Lock

代码事故，示例

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 进程安全锁 Lock

import time, threading

# 银行存款
money = 0

def change_money(value):
# 全局变量
global money

# 存了就马上取出，维持能量守恒定律
money = money + value
money = money - value

def run_thread(value):
for i in range(100000):
change_money(value)

def testThread():
# 线程 1
t1 = threading.Thread(target = run_thread, args = (5,))
# 线程 2
t2 = threading.Thread(target = run_thread, args = (8,))

t1.start()
t2.start()

t1.join()
t2.join()

# 理论值需要为0，由于出现进程相互竞争，导致出现非0
print(money)

testThread()

运行结果

D:\PythonProject>python main.py
0 nice

D:\PythonProject>python main.py
13  这个值不是我们喜欢的

加入Lock锁优化

# 银行存款
money = 0
# 创建一个锁
lock = threading.Lock()

def run_thread(value):
for i in range(100000):
# 获取锁
lock.acquire()
try:
change_money(value)
finally:
# 释放锁
lock.release()

然后就Ok了

锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行，坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。