网络编程之多线程——GIL全局解释器锁

网络编程之多线程——GIL全局解释器锁

1、引子

定义：
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple 
native threads from executing Python bytecodes at once. This lock is necessary mainly 
because CPython’s memory management is not thread-safe. (However, since the GIL 
exists, other features have grown to depend on the guarantees that it enforces.)

结论：在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，没法利用多核优点

首先须要明确的一点是GIL并非Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就比如C++是一套语言（语法）标准，可是能够用不一样的编译器来编译成可执行代码。有名的编译器例如GCC，INTEL C++，Visual C++等。Python也同样，一样一段代码能够经过CPython，PyPy，Psyco等不一样的Python执行环境来执行。像其中的JPython就没有GIL。然而由于CPython是大部分环境下默认的Python执行环境。因此在不少人的概念里CPython就是Python，也就想固然的把GIL归结为Python语言的缺陷。因此这里要先明确一点：GIL并非Python的特性，Python彻底能够不依赖于GIL。

2、GIL介绍

GIL本质就是一把互斥锁，既然是互斥锁，全部互斥锁的本质都同样，都是将并发运行变成串行，以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。

能够确定的一点是：保护不一样的数据的安全，就应该加不一样的锁。

要想了解GIL，首先肯定一点：每次执行python程序，都会产生一个独立的进程。例如python test.py，python aaa.py，python bbb.py会产生3个不一样的python进程

验证python test.py只会产生一个进程：

#test.py内容
import os,time
print(os.getpid())
time.sleep(1000)
#打开终端执行
python3 test.py
#在windows下查看
tasklist |findstr python
#在linux下下查看
ps aux |grep python

在一个python的进程内，不只有test.py的主线程或者由该主线程开启的其余线程，还有解释器开启的垃圾回收等解释器级别的线程，总之，全部线程都运行在这一个进程内，毫无疑问。

一、全部数据都是共享的，这其中，代码做为一种数据也是被全部线程共享的（test.py的全部代码以及Cpython解释器的全部代码）
例如：test.py定义一个函数work（代码内容以下图），在进程内全部线程都能访问到work的代码，因而咱们能够开启三个线程而后target都指向该代码，能访问到意味着就是能够执行。

二、全部线程的任务，都须要将任务的代码当作参数传给解释器的代码去执行，即全部的线程要想运行本身的任务，首先须要解决的是可以访问到解释器的代码。

综上：

若是多个线程的target=work，那么执行流程是

多个线程先访问到解释器的代码，即拿到执行权限，而后将target的代码交给解释器的代码去执行

解释器的代码是全部线程共享的，因此垃圾回收线程也可能访问到解释器的代码而去执行，这就致使了一个问题:对于同一个数据100，可能线程1执行x=100的同时，而垃圾回收执行的是回收100的操做，解决这种问题没有什么高明的方法，就是加锁处理，以下图的GIL，保证python解释器同一时间只能执行一个任务的代码。

3、GIL与Lock

机智的同窗可能会问到这个问题：Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为何这里还须要lock?

首先，咱们须要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据

而后，咱们能够得出结论：保护不一样的数据就应该加不一样的锁。

最后，问题就很明朗了，GIL 与Lock是两把锁，保护的数据不同，前者是解释器级别的（固然保护的就是解释器级别的数据，好比垃圾回收的数据），后者是保护用户本身开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock，以下图：

分析：

一、100个线程去抢GIL锁，即抢执行权限
二、确定有一个线程先抢到GIL（暂且称为线程1），而后开始执行，一旦执行就会拿到lock.acquire()
三、极有可能线程1还未运行完毕，就有另一个线程2抢到GIL，而后开始运行，但线程2发现互斥锁lock还未被线程1释放，因而阻塞，被迫交出执行权限，即释放GIL
四、直到线程1从新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，而后其余的线程再重复2 3 4的过程

代码示范：

from threading import Thread,Lock
import os,time
def work():
    global n
    lock.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()
    print(n) #结果确定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全，不加锁则结果可能为99

4、GIL与多线程

有了GIL的存在，同一时刻同一进程中只有一个线程被执行。

听到这里，有的同窗立马质问：进程能够利用多核，可是开销大，而python的多线程开销小，但却没法利用多核优点，也就是说python没用了，php才是最牛逼的语言？

别着急，还没讲完呢。

要解决这个问题，咱们须要在几个点上达成一致：

一、cpu究竟是用来作计算的，仍是用来作I/O的？
二、多cpu，意味着能够有多个核并行完成计算，因此多核提高的是计算性能
三、每一个cpu一旦遇到I/O阻塞，仍然须要等待，因此多核对I/O操做没什么用处

一个工人至关于cpu，此时计算至关于工人在干活，I/O阻塞至关于为工人干活提供所需原材料的过程，工人干活的过程当中若是没有原材料了，则工人干活的过程须要中止，直到等待原材料的到来。

若是你的工厂干的大多数任务都要有准备原材料的过程（I/O密集型），那么你有再多的工人，意义也不大，还不如一我的，在等材料的过程当中让工人去干别的活。

反过来说，若是你的工厂原材料都齐全，那固然是工人越多，效率越高

结论：

一、对计算来讲，cpu越多越好，可是对于I/O来讲，再多的cpu也没用
二、固然对运行一个程序来讲，随着cpu的增多执行效率确定会有所提升（无论提升幅度多大，总会有所提升），这是由于一个程序基本上不会是纯计算或者纯I/O，因此咱们只能相对的去看一个程序究竟是计算密集型仍是I/O密集型，从而进一步分析python的多线程到底有无用武之地

假设咱们有四个任务须要处理，处理方式确定是要玩出并发的效果，解决方案能够是：

方案一：开启四个进程
方案二：一个进程下，开启四个线程

单核状况下，分析结果:

一、若是四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜
二、若是四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜

结论：

如今的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提高，甚至不如串行(没有大量切换)，可是，对于IO密集型的任务效率仍是有显著提高的。

5、多线程性能测试

若是并发的多个任务是计算密集型：多进程效率高

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()) #本机为4核
    start=time.time()
    for i in range(4):
        p=Process(target=work) #耗时5s多
        p=Thread(target=work) #耗时18s多
        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) #耗时12s多,大部分时间耗费在建立进程上
        p=Thread(target=work) #耗时2s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

应用：

一、多线程用于IO密集型，如socket，爬虫，web
二、多进程用于计算密集型，如金融分析