多线程间的资源竞争
以下列task1()，task2()两个函数为例，分别将对全局变量num加一重复一千万次循环（数据大一些，太小的话执行太快，达不到验证的效果）。
import threading
import time
num = 0
def task1(nums):
global num
for i in range(nums):
num += 1
print("task1---num=%d" % num)
def task2(nums):
global num
for i in range(nums):
num += 1
print("task2---num=%d" % num)
if __name__ == '__main__':
nums = 10000000
t1 = threading.Thread(target=task1, args=(nums,))
t2 = threading.Thread(target=task2, args=(nums,))
t1.start()
t2.start()
# 因为主线程不会等子线程执行完就会执行，所以这里延迟五秒，确保最后执行。
time.sleep(5)
print("main----num=%d" % num)
程序运行结果：
如图，输出结果比较混乱，既没有一千万，最终结果也不是二千万。因为多线程运行时出现了资源竞争，即可以理解为，每个函数运行的时间都不确定，且互相影响，
如从初始值0开始，假设t1的线程先执行，执行到+1后，此时的num=1还未存储，然后即被叫停，t2开始执行，去获取num，获取到的num等于初始值0，然后其执行了+1并存储，存储后num=1，然后t2停止t1继续，再次存储num=1。即加了两次1，但是num还是只等于1。
因为t1和t2谁来运行的分配是完全随机的，所以最后加了两千万次1后值是小于2000万的。
解决此类问题，可以使用到互斥锁 。
互斥锁
- 某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定"，其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。
- 互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
互斥锁示例
创建一把锁：
mutex = threading.Lock()
mutex.acquire() # 上锁
xxxx锁定的内容xxxxx
mutex.release() # 解锁
将互斥锁加入到上边的代码中如下，则问题得到了解决。
import threading
import time
num = 0
def task1(nums):
global num
mutex.acquire()
for i in range(nums):
num += 1
mutex.release()
print("task1---num=%d" % num)
def task2(nums):
global num
mutex.acquire()
for i in range(nums):
num += 1
mutex.release()
print("task2---num=%d" % num)
if __name__ == '__main__':
nums = 10000000
mutex = threading.Lock()
t1 = threading.Thread(target=task1, args=(nums,))
t2 = threading.Thread(target=task2, args=(nums,))
t1.start()
t2.start()
# 因为主线程不会等子线程执行完就会执行，所以这里延迟五秒，确保最后执行。
time.sleep(5)
print("main----num=%d" % num)
程序运行结果：
可重入锁与不可重入锁
threading.Lock()上的是不可重入锁，即一次只能加一把锁，不能加多把。
threading.Lock()
如果需要同时加多把所，则需加入不可重入锁
创建一把可重入锁：
mutex = threading.RLock()
mutex.acquire() # 上锁
mutex.acquire() # 再上锁
xxxx锁定的内容xxxxx
mutex.release() # 解锁
mutex.release() # 再解锁
其中上锁和解锁的次数必须保持一致。
死锁
在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会程序堵塞，造成死锁。
- 死锁一般用不到。
- 程序设计要尽量避免。
