GIL

GIL（Global Interpreter Look）：全局解释器锁，为了避免线程竞争资源造成数据错乱。

其实每个py程序都必须有解释器参加，解释器就是一堆代码，就等于多线程要竞争同一个解释器的代码，所以要给解释器加互斥锁。而且除了自己开的线程，还有用于垃圾回收的系统线程等，所以必须加锁

加锁以后，就意味着线程只能并发，同一时间只有一个cpu在处理线程，看起来效率很低，其实是要看cpu是用来做计算还是用来做io操作的。

如果是在io密集的程序中，cpu性能无法直接决定程序的执行速度。在计算密集的程序中，cpu的性能可以直接决定程序的执行速度。

from threading import Thread
from multiprocessing import Process
import time

def task1():
    sum = 1
    for i in range(10000000):
        sum *= i

def task2():
    sum = 1
    for i in range(10000000):
        sum *= i

def task3():
    sum = 1
    for i in range(10000000):
        sum *= i
if __name__ == '__main__':
    # 开始时间
    st_time = time.time()
    t1 = Process(target=task1)
    t2 = Process(target=task2)
    t3 = Process(target=task3)

    t1.start()
    t2.start()
    t3.start()

    t1.join()
    t2.join()
    t3.join()

    print(time.time()-st_time)

计算密集测试（多进程效率高）

from threading import Thread
import time

def task1():
    time.sleep(3)

def task2():
    time.sleep(3)

def task3():
    time.sleep(3)

    # 开始时间
    st_time = time.time()
    t1 = Thread(target=task1)
    t2 = Thread(target=task2)
    t3 = Thread(target=task3)

    t1.start()
    t2.start()
    t3.start()

    t1.join()
    t2.join()
    t3.join()

    print(time.time() - st_time)

IO密集测试（多线程效率高）

GIL与自定义互斥锁的区别：

GIL只能保证解释器代码的数据的安全，要想保证开启的线程安全必须加互斥锁