GIL(全局解释器锁)

1、互斥锁：局部并行改串行，牺牲效率保证数据安全

2、不同的数据需用不同的锁

一个进程中多线程，只能由单核处理，多核优势处理需开多进程。

垃圾回收线程不是随时都在

因GIL锁的原因，一个进程内多个线程同时只能有一个线程执行代码，也就失去了多核优势。

3、python多线程应该怎么用？

对计算来说，cpu越多越好，但是I/O操作来说，CPU再多也无用。

计算密集型应该用多进程，I /O密集型多线程。

计算密集型多进程与多线程对比：

多进程，耗时11.876922607421875秒：

from multiprocessing import Process
import os,time
def work():
    res=0
    for i in range(100000000):
        res*=i
if __name__=='__main__':
    l=[]
    print(os.cpu_count())#看机器是多少核心
    start=time.time()
    for i in range(4):
        p=Process(target=work)
        l.append(p)
        p.start()
    for i in l:
        i.join()
    stop=time.time()
    print('run time is %s' % (stop-start))

多线程计算，耗时29.74070429801941秒：

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())
    start=time.time()
    for i in range(4):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for i in l:
        i.join()
    stop=time.time()
    print('run time is %s' % (stop-start))

I/O密集型多进程与多线程对比：

多进程，耗时3.7秒

from multiprocessing import Process
import os
import time
def work():
    time.sleep(2)
if __name__ == "__main__":
    l=[]
    start=time.time()
    for i in range(400):
        p=Process(target=work)
        l.append(p)
        p.start()
    for i in l:
        i.join()
    end=time.time()
    print("run time is:%s" % (end-start))

多线程，耗时2.1秒

from threading import Thread
import time
def work():
    time.sleep(2)
if __name__ == "__main__":
    l=[]
    start=time.time()
    for i in range(400):
        p = Thread(target=work)
        l.append(p)
        p.start()
    for i in l:
        i.join()
    end=time.time()
    print("run time is:%s" % (end-start))