python：threading多线程模

假设我们有一个公共数据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()