GIL全局解释器锁

1、什么是GIL全局解释器锁

GIL本质是一把互斥锁，相当于执行权限，每个进程内都会存在一把GIL同一进程内的多线程，必须抢到GIL之后才能使用Cpython解释器来执行自己的代码，即同一进程下的多个线程无法实现并行，但可以实现并发

Cpython解释器下想实现并行可以开启多个进程

2、为何要有GIL

因为Cpython解释器的垃圾回收机制不是线程安全的，保证了数据的安全

3、GIL全局解释器的优缺点

优点：保证了数据安全

缺点：单个进程下开启多个线程只能实现并发不能实现并行

4、选择多进程还是多线程？

单核或多核I/O密集型下使用：多线程

单核计算密集型下使用：多线程

多核计算密集型下使用：多进程

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

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

对于一个程序来说不可能是纯IO型或者纯计算型，我们只能相对的判断是IO密集型还是计算密集型，来选择多进程还是多线程

单核情况下：

开启四个任务是计算密集型的，没有多核来并行计算，开多个进程，只是徒增进程的开销内存资源，应该使用多线程

开启四个任务是IO密集型的，开启多进程也是徒增，来回切换的速度还不如开启多线程的，所以应该使用多线程

多核情况下：

开启四个任务是计算密集型的，多核意味着多个CPU去计算，开启多进程可以同一时刻去计算，所以应该使用多进程

开启四个任务是IO密集型的，再多的核也在在等待，来回切换的速度进程不如线程的，所以应该使用多线程

5、多线程多进程多核下性能测试

from multiprocessing import Process

from threading import Thread

import os

import time

# 计算密集型

def task1():

    i = 0

    for line in range(110000000):

        i += 1

if __name__ == '__main__':

    print(os.cpu_count())  # 查看计算机几核的

    list1 = []

    start_time = time.time()

    for i in range(4):

        p1 = Process(target=task1)  # 4进程下： 17.369488954544067

        # t1 = Thread(target=task1) # 4线程下： 27.991361618041992

        p1.start()

        # t1.start()

        # list1.append(t1)

        list1.append(p1)

    for i in list1:

        i.join()

    end_time = time.time()

    print(end_time - start_time)

# IO密集型

def task2():

    time.sleep(1)

if __name__ == '__main__':

    print(os.cpu_count())

    start_time = time.time()

    list2 = []

    for i in range(40):

        # p2 = Process(target=task2) #40进程下： 11.374541282653809

        t2 = Thread(target=task2)  # 40线程下： 1.010239839553833

        # p2.start()

        t2.start()

        # list2.append(p2)

        list2.append(t2)

    for i in list2:

        i.join()

    end_time = time.time()

    print(end_time - start_time)

协程

1、什么是协程

进程：资源单位

线程：执行单位

协程：单线程下实现并发

在I/O密集型的情况下，使用协程提高执行效率

手动的实现在同一线程下 “ 遇到I/O切换+保存状态 ” 让操作系统误以为没有I/O操作，将CPU执行权限继续交给你

即：在单线程下实现多个任务遇到IO就切换可以降低单线程的IO时间，从而最大限度的提升单线程的效率

2、实现协程

gevent模块：遇到I/O自动切换并保存状态

使用gevent模块中的monkey，monkey.patch_all()来监视是否遇到IO操作，再使用spawn来创建协程，使用joinall替代join，使协程运行完再结束线程，joinall中放入得到的对象到列表中

from gevent import spawn

from gevent import joinall

from gevent import monkey

import time

# 补丁：监听所有的任务是否有IO操作

monkey.patch_all()

def task1(name):

    print(f'{name}开始')

    time.sleep(1)

    print(f'{name}结束')

def task2():

    print('task2开始')

    time.sleep(3)

    print('task2结束')

def task3():

    print('task3开始')

    time.sleep(5)

    print('task3结束')

if __name__ == '__main__':

    start_time = time.time()

    # 创建协程

    sp1 = spawn(task1,'task1')

    sp2 = spawn(task2)

    sp3 = spawn(task3)

    # sp1.join()

    # sp2.join()

    # sp3.join()

    joinall([sp1, sp2, sp3]) # 相当于 sp.join()，注意放入列表中

    end_time = time.time()

    print(end_time - start_time)

    # task1开始

    # task2开始

    # task3开始

    # task1结束

    # task2结束

    # task3结束

    # 5.013161897659302