线程安全

在一个进程内的所有线程是共享全局变量，共享数据，但是多个线程对变量进行修改操作，就可能资源竞争导致数据错误。 如:

import threading
num = 0

def work1():
global num
for i in range(1000000):
num += 1
print(num)

def work2():
global num
for i in range(1000000):
num += 1
print(num)

if __name__ == '__main__':
first_threading = threading.Thread(target=work1)
second_threading = threading.Thread(target=work2)
first_threading.start()
second_threading.start()

结果

1212612
1226204

全局变量num，被两个线程做加一操作，无论线程的执行顺序怎么样，最后的结果，应该是2000000才对。但是，最后的结果却小于2000000，为什么：

 例如图1：加入线程work1刚取到num=0,还没有来的急加一操作，此时cpu就线程work2抢走，work2读取的num=0，那么线程work1和work2加一操作的计算结果都是1，最后num=1,但实际加了两次，所以num最后的结果必然会小。

那么如果像图二那种情况呢，可能减少的就更加明显，work2取到num=0,还是没有来得及进行加一，此时被work1抢走，num=0,work1对num进行了多次加一操作，num远大于1，然后work2才开始加1，但是是num=0+1=1,计算结果反而变小了。

那么如何避免线程在操作全局变量的时候，资源竞争的行为呢？

import threading
num = 0

def work1():
global num
for i in range(1000000):
num += 1
print(num)

def work2():
global num
for i in range(1000000):
num += 1
print(num)

if __name__ == '__main__':
first_threading = threading.Thread(target=work1)
second_threading = threading.Thread(target=work2)
first_threading.start()
first_threading.join()
second_threading.start()

1000000
2000000

用join去阻塞第二个线程的开启，这就相当于，work1先执行，执行完成之后，work2在执行，但是这样开线程的目的就没有了。

import threading
lock = threading.Lock()
num = 0

def work1():
global num
for i in range(1000000):
lock.acquire()
num += 1
lock.release()
print(num)

def work2():
global num
for i in range(1000000):
lock.acquire()
num += 1
lock.release()
print(num)

if __name__ == '__main__':
first_threading = threading.Thread(target=work1)
second_threading = threading.Thread(target=work2)
first_threading.start()
second_threading.start()
print("主线程继续。。。。。。")

结果

主线程继续。。。。。。
1982313
2000000

采用互斥锁，来保证加一操作期间不会别其他进程同时操作num。
当一个现成调用acquire（），那么索就进入blocked的状态，此时如果有另一个线程调用acquire（），那么他将被阻塞，直到拥有锁的线程release。
互斥锁有点：可以让关键代码只能由一个现成从头到尾的执行完，缺点：不能并发（但是python本身有GIL。），可能死锁。