（六）多线程之 GIL全局解释器锁

‘‘‘
定义：
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，本质就是一把互斥锁(mutex)，这把互斥锁是阻止了多个活跃的线程，
同一时间只能运行一次 python的字节码(python解释器的代码)，这把锁是非常重要的，因为 CPython的
内存管理(垃圾回收机制)不是线程安全的，（无论如何，有了这把锁的存在，python的一些其他的特性都依赖于这把锁）
"""

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

# test.py内容
import os,time
print(os.getpid())
time.sleep(1000)

# 打开终端执行
python3 test.py

# 在windows下查看
tasklist |findstr python

# 在linux下下查看
ps aux |grep python

"""
1，所有数据都是共享的，这其中，代码作为一种数据也是被所有线程共享的（test.py的所有代码以及Cpython解释器的所有代码）
   例如：test.py定义一个函数work（代码内容如下图），在进程内所有线程都能访问到work的代码，于是我们可以开启三个线程
        然后target都指向该代码，能访问到意味着就是可以执行。

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

# 1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来

# 2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

"""
所有线程抢的是GIL锁，或者说所有线程抢的是执行权限。

线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，
有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走
执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果。

既然是串行，那我们执行

t1.start()

t1.join

t2.start()

t2.join()

这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，
而Lock只是锁住一部分操作共享数据的代码。
"""

from threading import Thread
import time

def work():
    global n
    temp = n
    time.sleep(0.1)
    n = temp-1
    
if __name__ == ‘__main__‘:
    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)    # 结果可能为99

import threading

T = threading.Lock()

T.acquire()
‘‘‘
对公共数据的操作
‘‘‘
T.release()

from threading import Thread,Lock
import 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，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

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

# 有人会说：既然加锁会让运行变成串行,那么我在start之后立即使用join,就不用加锁了啊,也是串行的效果啊
# 没错:在start之后立刻使用jion,肯定会将100个任务的执行变成串行,毫无疑问,最终n的结果也肯定是0,是安全的,但问题是
# start后立即join:任务内的所有代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的
# 单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高.

"""
1，GIL 保证了一件事是一个进程内的多个线程，它们同一时间只能有一个执行，这么做是因为，我想要保证
   python的垃圾回收是线程安全的，加了一把GIL锁，产生的效果是，多个线程只能有一个出来运行。
   
2，针对不同的数据，就应该加不同的锁，解释器级别的GIL锁，保护的是解释器级别的数据，保护不了用户自己的数据，
   针对自己的共享数据，需要自己加锁处理。
   
3，工作流程，各个线程首先抢的并不是 mutex，而是GIL锁，它需要获得执行权限，接下来才会抢 mutex。
"""

# 1，cpu到底是用来做计算的，还是用来做I/O的？cpu是做计算的，碰到I/O的话会去干别的活。

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

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

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

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

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

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

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

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

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

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())   # 本机为8核
    start = time.time()
    for i in range(8):
        # p = Process(target=work)    # 耗时8s多
        p = Thread(target=work)     # 耗时39s多
        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 os,time

def work():
    time.sleep(2)

if __name__ == ‘__main__‘:
    l = []
    print(os.cpu_count())   # 本机为8核
    start = time.time()
    for i in range(400):
        p = Process(target=work)  # 耗时11s多,大部分时间耗费在创建进程上
        # 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))

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

from threading import Thread,Lock
import time

mutexA = Lock()
mutexB = Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print(‘\033[41m%s 拿到A锁\033[0m‘ %self.name)

        mutexB.acquire()
        print(‘\033[42m%s 拿到B锁\033[0m‘ %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print(‘\033[43m%s 拿到B锁\033[0m‘ %self.name)
        time.sleep(2)

        mutexA.acquire()
        print(‘\033[44m%s 拿到A锁\033[0m‘ %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == ‘__main__‘:
    for i in range(10):
        t = MyThread()
        t.start()

"""
Thread-1 拿到A锁
Thread-1 拿到B锁
Thread-1 拿到B锁
Thread-2 拿到A锁
卡住了，死锁了，整个程序阻塞住
"""

from threading import Thread,RLock
import time
# 一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程
# 都只能等待，等待该线程释放所有锁，即counter递减到0为止
mutexA = mutexB = RLock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print(‘\033[41m%s 拿到A锁\033[0m‘ %self.name)

        mutexB.acquire()
        print(‘\033[42m%s 拿到B锁\033[0m‘ %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print(‘\033[43m%s 拿到B锁\033[0m‘ %self.name)
        time.sleep(2)

        mutexA.acquire()
        print(‘\033[44m%s 拿到A锁\033[0m‘ %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == ‘__main__‘:
    for i in range(10):
        t = MyThread()
        t.start()