假设我们有一个公共数据x(也可以叫共享资源,临界资源),然后跑10个线程都去访问这变量并对这个变量进行修改的操作,那么就得到意料之外的结果。
ps:以下代码来自《征服python-语言基础于典型应用》
import threading # 导入threading模块
import time # 导入time模块
class mythread(threading.Thread): # 通过继承创建类
def __init__(self,threadname): # 初始化方法
# 调用父类的初始化方法
threading.Thread.__init__(self,name = threadname)
def run(self): # 重载run方法
global x # 使用global表明x为全局变量
for i in range(3):
x = x + 1
time.sleep(2) # 调用sleep函数,让线程休眠5秒
print x
tl = [] # 定义列表
for i in range(10):
t = mythread(str(i)) # 类实例化
tl.append(t) # 将类对象添加到列表中
x=0 # 将x赋值为0
for i in tl:
i.start() # 依次运行线程
#######运行结果######
[root@localhost ~]# python syn.py
30
30
30
30
30
30
30
30
30
30
由于x是全局变量(共享资源),每个线程对x操作后就休眠了
在线程休眠的时候其他线程也都开始执行操作,
最终休眠5秒后x的值最终就被修改为30了
使用互斥锁来保护公共资源。用互斥锁来保证同一时刻只有一个线程访问公共资源,实现简单的同步
互斥锁:threading.Lock
互斥锁方法:acquire() 获取锁 release():释放锁
当有一个线程获的锁之后,这把锁就会进入locke状态(被锁起来了),另外的线程试图获取锁的时候就会变成同步阻塞状态,
当拥有线程锁的的线程调用锁方法 release()之后就会释放锁,那么锁就会变成开锁unlocked状态,之后再从同步阻塞状态的线程中选择一个来获得锁
import threading # 导入threading模块
import time # 导入time模块
class mythread(threading.Thread): # 通过继承创建类
def __init__(self,threadname): # 初始化方法
threading.Thread.__init__(self,name = threadname)
def run(self): # 重载run方法
global x # 使用global表明x为全局变量
lock.acquire() # 调用lock的acquire方法
for i in range(3):
x = x + 1
time.sleep(2) # 调用sleep函数,让线程休眠5秒
print x
lock.release() # 调用lock的release方法
lock = threading.Lock() # 类实例化
tl = [] # 定义列表
for i in range(10):
t = mythread(str(i)) # 类实例化
tl.append(t) # 将类对象添加到列表中
x=0 # 将x赋值为0
for i in tl:
i.start() # 依次运行线程
######运行结果######
[root@localhost ~]# python syn.py
3
6
9
12
15
18
21
24
27
30
可重入锁:threading.RLock()
方法和互斥锁一样。
假设一个锁嵌套的情况:有个线程以及获取到锁和共享资源了,但是又需要一把锁来获取另外一个资源,那么只要把代码里面的:
lock = threading.Lock()
修改为:
lock = threading.RLock()