Python3 GIL(Global Interpreter Lock)与多线程

GIL(Global Interpreter Lock)与多线程

GIL介绍
GIL与Lock
GIL与多线程
多线程性能测试

在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势。

GIL并不是Python的特性，他是在实现Python解释器（Cpython）时所引入的一个概念，因为Cpython是大部分环境下默认的Python执行环境。

所以要明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

一 GIL介绍

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

有了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()

'''

python3 test.py

#在windows下

tasklist |findstr python

#在linux下

ps aux |grep python

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

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

# 所有数据都是共享的，这其中，代码作为一种数据也是被所有线程共享的（test.py的所有代码以及Cpython解释器的所有代码）

例如：test.py定义一个函数work（代码内容如下图），在进程内所有线程都能访问到work的代码，于是我们可以开启三个线程然后target都指向该代码，能访问到意味着就是可以执行。

# 所有线程的任务，都需要将任务的代码当做参数传给解释器的代码去执行，即所有的线程要想运行自己的任务，首先需要解决的是能够访问到解释器的代码。

综上：

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

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

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

二 GIL与Lock

GIL保护的是解释器级的数据，保护用户自己的数据则需要自己加锁处理，如下图

三 GIL与多线程

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

进程可以利用多核，但是开销大，而python的多线程开销小，但却无法利用多核优势，也就是说python没用了？

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

#. cpu到底是用来做计算的，还是用来做I/O的？

#. 多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能

#. 每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处

　　对计算来说，cpu越多越好，但是对于I/O来说，再多的cpu也没用

　　当然对运行一个程序来说，随着cpu的增多执行效率肯定会有所提高（不管提高幅度多大，总会有所提高），这是因为一个程序基本上不会是纯计算或者纯I/O，所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型，从而进一步分析python的多线程到底有无用武之地

比如：

　　在IO密集型的情况运行四个任务：1、开四个进程在四个CPU上并行运行，执行完四个任务的时间为最长的那个任务执行的时间

　　　　　　　　　　　　　　　　　2、开四个线程在同一个CPU上并发运行，执行完四个任务的时间也是为最长的那个执行任务的时间。

　　　　　　　　　　　　　　　　　甚至，多线程执行完的时间比多进程的还要慢，因为创建一个线程比创建一个进程要快的多（进程需要向操作系统申请内存空间，放入一系列相关资源）

#分析：

我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：

方案一：开启四个进程

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

#单核情况下，分析结果:

　　如果四个任务是计算密集型，没有多核来并行计算，方案一徒增了创建进程的开销，方案二胜

　　如果四个任务是I/O密集型，方案一创建进程的开销大，且进程的切换速度远不如线程，方案二胜

#多核情况下，分析结果：

　　如果四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜

　　如果四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜

#结论：现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。

四多线程性能测试

from multiprocessing import Process

from threading import Thread

import os,time

def work():

    res=

    for i in range():

        res*=i

if __name__ == '__main__':

    l=[]

    print(os.cpu_count()) #本机为4核

    start=time.time()

    for i in range():

        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))

计算密集型：多进程效率高

from multiprocessing import Process

from threading import Thread

import threading

import os,time

def work():

    time.sleep()

    print('===>')

if __name__ == '__main__':

    l=[]

    print(os.cpu_count()) #本机为4核

    start=time.time()

    for i in range():

        # 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))

I/O密集型：多线程效率高

IO密集型：多线程效率高

应用：

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