标签：java The 线程 数学 高并发 doc 多进程 单线程 特性
关于我
一个有思想的程序猿，终身学习实践者，目前在一个创业团队任team lead，技术栈涉及Android、Python、Java和Go，这个也是我们团队的主要技术栈。
Github：https://github.com/hylinux1024
微信公众号：终身开发者(angrycode)
A global interpreter lock (GIL) is a mechanism used in computer-language interpreters to synchronize the execution of threads so that only one native thread can execute at a time. --引用自wikipedia
从上面的定义可以看出，GIL是计算机语言解析器用于同步线程执行的一种同步锁机制。很多编程语言都有GIL，例如Python、Ruby。
Python作为一种面向对象的动态类型编程语言，开发者编写的代码是通过解析器顺序解析执行的。
大多数人目前使用的Python解析器是CPython提供的，而CPython的解析器是使用引用计数来进行内存管理，为了对多线程安全的支持，引用了global intepreter lock，只有获取到GIL的线程才能执行。如果没有这个锁，在多线程编码中即使是简单的操作也会引起共享变量被多个线程同时修改的问题。例如有两个线程同时对同一个对象进行引用时，这两个线程都会将变量的引用计数从0增加为1，明显这是不正确的。
可以通过sys模块获取一个变量的引用计数
>>> import sys
>>> a = []
>>> sys.getrefcount(a)
2
>>> b = a
>>> sys.getrefcount(a)
3sys.getrefcount()方法中的参数对a的引用也会引起计数的增加。
是否可以对每个变量都分别使用锁来同步呢？
如果有多个锁的话，线程同步时就容易出现死锁，而且编程的复杂度也会上升。当全局只有一个锁时，所有线程都在竞争一把锁，就不会出现相互等待对方锁的情况，编码的实现也更简单。此外只有一把锁时对单线程的影响其实并不是很大。
Python核心开发团队以及Python社区的技术专家对移除GIL也做过多次尝试，然而最后都没有令各方满意的方案。
内存管理技术除了引用计数外，一些编程语言为了避免引用全局解析锁，内存管理就使用垃圾回收机制。
当然这也意味着这些使用垃圾回收机制的语言就必须提升其它方面的性能（例如JIT编译），来弥补单线程程序的执行性能的损失。
对于Python的来说，选择了引用计数作为内存管理。一方面保证了单线程程序执行的性能，另一方面GIL使得编码也更容易实现。
在Python中很多特性是通过C库来实现的，而在C库中要保证线程安全的话也是依赖于GIL。
所以当有人成功移除了GIL之后，Python的程序并没有变得更快，因为大多数人使用的都是单线程场景。
首先来GIL对IO密集型程序和CPU密集型程序的的区别。
像文件读写、网络请求、数据库访问等操作都是IO密集型的，它们的特点需要等待IO操作的时间，然后才进行下一步操作；而像数学计算、图片处理、矩阵运算等操作则是CPU密集型的，它们的特点是需要大量CPU算力来支持。
对于IO密集型操作，当前拥有锁的线程会先释放锁，然后执行IO操作，最后再获取锁。线程在释放锁时会把当前线程状态存在一个全局变量PThreadState的数据结构中，当线程获取到锁之后恢复之前的线程状态
用文字描述执行流程
保存当前线程的状态到一个全局变量中
释放GIL
... 执行IO操作 ...
获取GIL
从全局变量中恢复之前的线程状态下面这段代码是测试单线程执行500万次消耗的时间
import time
COUNT = 50000000
def countdown(n):
while n > 0:
n -= 1
start = time.time()
countdown(COUNT)
end = time.time()
print('Time taken in seconds -', end - start)
# 执行结果
# Time taken in seconds - 2.44541597366333在我的8核的macbook上跑大约是2.4秒，然后再看一个多线程版本
import time
from threading import Thread
COUNT = 50000000
def countdown(n):
while n > 0:
n -= 1
t1 = Thread(target=countdown, args=(COUNT // 2,))
t2 = Thread(target=countdown, args=(COUNT // 2,))
start = time.time()
t1.start()
t2.start()
t1.join()
t2.join()
end = time.time()
print('Time taken in seconds -', end - start)
# 执行结果
# Time taken in seconds - 2.4634649753570557上文代码每个线程都执行250万次，如果线程是并发的，执行时间应该是上面单线程版本的一半时间左右，然而在我电脑中执行时间大约为2.5秒！
多线程不但没有更高效率，反而还更耗时了。这个例子就说明Python中的线程是顺序执行的，只有获取到锁的线程可以获取解析器的执行时间。多线程执行多出来的那点时间就是获取锁和释放锁消耗的时间。
那如何实现高并发呢？
答案是使用多进程。前面的文章有介绍多进程的使用
from multiprocessing import Pool
import time
COUNT = 50000000
def countdown(n):
while n > 0:
n -= 1
if __name__ == '__main__':
pool = Pool(processes=2)
start = time.time()
r1 = pool.apply_async(countdown, [COUNT // 2])
r2 = pool.apply_async(countdown, [COUNT // 2])
pool.close()
pool.join()
end = time.time()
print('Time taken in seconds -', end - start)
# 执行结果
# Time taken in seconds - 1.2389559745788574使用多进程，每个进程运行250万次，大约消耗1.2秒的时间。差不多是上面线程版本的一半时间。
当然还可以使用其它Python解析器，例如Jython、IronPython或PyPy。
既然每个线程执行前都要获取锁，那么有一个线程获取到锁一直占用不释放，怎么办？
IO密集型的程序会主动释放锁，但对于CPU密集型的程序或IO密集型和CPU混合的程序，解析器将会如何工作呢？
早期的做法是Python会执行100条指令后就强制线程释放GIL让其它线程有可执行的机会。
可以通过以下获取到这个配置
>>> import sys
>>> sys.getcheckinterval()
100在我的电脑中还打印了下面的输出警告
Warning (from warnings module):
File "__main__", line 1
DeprecationWarning: sys.getcheckinterval() and sys.setcheckinterval() are deprecated. Use sys.getswitchinterval() instead.意思是sys.getcheckinterval()方法已经废弃，应该使用sys.getswitchinterval()方法。
因为传统的实现中每解析100指令的就强制线程释放锁的做法，会导致CPU密集型的线程会一直占用GIL而IO密集型的线程会一直得不到解析的问题。于是新的线程切换方案就被提出来了
>>> sys.getswitchinterval()
0.005这个方法返回0.05秒，意思是每个线程执行0.05秒后就释放GIL，用于线程的切换。
在CPython解析器的实现由于global interpreter lock(全局解释锁)的存在，任何时刻都只有一个线程能执行Python的bytecode(字节码)。
常见的内存管理方案有引用计数和垃圾回收，Python选择了前者，这保证了单线程的执行效率，同时对编码实现也更加简单。想要移除GIL是不容易的，即使成功将GIL去除，对Python的来说是牺牲了单线程的执行效率。
Python中GIL对IO密集型程序可以较好的支持多线程并发，然而对CPU密集型程序来说就要使用多进程或使用其它不使用GIL的解析器。
目前最新的解析器实现中线程每执行0.05秒就会强制释放GIL，进行线程的切换。
标签：java The 线程 数学 高并发 doc 多进程 单线程 特性
原文地址：https://www.cnblogs.com/angrycode/p/11396808.html
