Python GIL(Global Interpreter Lock) 解释器锁
GIL本质就是一把互斥锁，将并发变成串行，以此来控制同一时间共享数据只能被一个任务所修改，进而保证数据的安全性。在Cpython解释器中，同一个进程下开启多线程，同一时刻只能有一个线程执行，无法利用多核优势。GIL并不是Python的特性，Python完全可以不依赖于GIL。
线程互斥锁的示例：
from threading import Thread, Lock
import time
n = 100
def task():
global n
with mutex: # 获取锁 相当于 mutex.acquire() 和 mutex.release()
temp = n
time.sleep(0.1)
n = temp - 1
if __name__ == '__main__':
starttime = time.time()
mutex = Lock() # 生成一个锁对象
t_l = []
for i in range(100):
t = Thread(target=task)
t_l.append(t)
t.start()
for t in t_l:
t.join()
stoptime = time.time()
print('主线程 %s ' % n)
print('run time is %s' % (stoptime - starttime))
输出结果：
主线程 0
run time is 10.062247514724731
如果不加锁，则出现如下结果：
主线程 99
run time is 0.11712527275085449
- CPU是用来做计算的，在I/O密集性的任务下，并不能发挥CPU的多核优势，反而使用线程开销更小，任务处理更快。
- 在计算型任务中，使用多进程可以利用计算机的多核优势，能并行执行任务，速度更快。
计算密集型任务，多进程和和线程的效率比较
from multiprocessing import Process
from threading import Thread
import os,time
def work():
res=0
for i in range(100000000):
res*=i
if __name__ == '__main__':
l=[]
print(os.cpu_count()) #本机为12核
start=time.time()
for i in range(12):
p=Process(target=work) # 使用多进程时间为 9.17792010307312
p=Thread(target=work) # 使用多线程时间为 43.76649355888367
l.append(p)
p.start()
for p in l:
p.join()
stop=time.time()
print('run time is %s' %(stop-start))
# 计算密集型：多进程效率更高
I/O密集型任务，多进程和多线程的效率比较
from multiprocessing import Process
from threading import Thread
import threading
import os,time
def work():
time.sleep(2)
print('===>')
if __name__ == '__main__':
l=[]
print(os.cpu_count()) #本机为4核
start=time.time()
for i in range(400):
p=Process(target=work) # 使用多进程，耗时 6.676343202590942
p=Thread(target=work) # 使用多线程，耗时 2.049600124359131
l.append(p)
p.start()
for p in l:
p.join()
stop=time.time()
print('run time is %s' %(stop-start))
# I/O密集型：多线程效率高
现在计算机基本上都是多核，python对于计算密集型的任务开多个线程的效率并不能带来多大的提升，甚至如串行（没有大量的切换），但是，对于I/O密集型的任务效率还是有显著提升的。
- 多线程用于IO密集型，如Socket, 爬虫，web
- 多进程用于计算密集型，如金融分析
GIL和python应用程序锁的关系
GIL锁并不会保护python程序中的数据，只在解释器级别实现锁的机制，在python应用中，如果遇到IO操作，已经获得锁的线程或者进程或保留锁的状态，其他线程在这种状态下获取锁进行问的操作。
