Python GIL 机制

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操作，已经获得锁的线程或者进程或保留锁的状态，其他线程在这种状态下获取锁进行问的操作。