GIL全局解释器锁与协程

一、GIL全局解释器锁

在同一个进程下开启的多线程，同一时刻只能有一个线程执行，因为Cpython的内存管理不是线程安全

GIL全局解释器锁，本质上就是一把互斥锁，保证数据安全

import time
from threading import Thread

n = 100


def task():
    global n
    m = n
    time.sleep(3)
    n = m - 1


if __name__ == '__main__':
    list1 = []
    for line in range(10):
        t = Thread(target=task)
        t.start()
        list1.append(t)

    for t in list1:
        t.join()

    print(n)

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

优点：

　　保证数据的安全性

缺点：

　　单个进程下，开启多个线程，牺牲执行效率，无法实现并行，只能实现并发

不同情况下使用多进程或者多线程比较

IO密集型下使用多线程.
计算密集型下使用多进程

# 计算密集型任务
def task1():
    # 计算1000000次 += 1
    i = 10
    for line in range(10000000):
        i += 1


# IO密集型任务·
def task2():
    time.sleep(3)


if __name__ == '__main__':
    # 1、测试多进程:
    # 测试计算密集型
    start_time = time.time()
    list1 = []
    for line in range(6):
        p = Process(target=task1)
        p.start()
        list1.append(p)
    for p in list1:
        p.join()
    end_time = time.time()
    # 消耗时间: 0.9640259742736816
    print(f'计算密集型消耗时间: {end_time - start_time}')

    # 测试IO密集型
    start_time = time.time()
    list1 = []
    for line in range(6):
        p = Process(target=task2)
        p.start()
        list1.append(p)
    for p in list1:
        p.join()
    end_time = time.time()
    # 消耗时间: 3.1492795944213867
    print(f'IO密集型消耗时间: {end_time - start_time}')


    # 2、测试多线程:
    # 测试计算密集型
    start_time = time.time()
    list1 = []
    for line in range(6):
        p = Thread(target=task1)
        p.start()
        list1.append(p)
    for p in list1:
        p.join()
    end_time = time.time()
    # 消耗时间: 3.3614895343780518
    print(f'计算密集型消耗时间: {end_time - start_time}')

    # 测试IO密集型
    start_time = time.time()
    list1 = []
    for line in range(6):
        p = Thread(target=task2)
        p.start()
        list1.append(p)
    for p in list1:
        p.join()
    end_time = time.time()
    # 消耗时间: 3.002037763595581
    print(f'IO密集型消耗时间: {end_time - start_time}')

二、协程

进程、线程、协程：　

- 进程: 资源单位
- 线程: 执行单位
- 协程: 单线程下实现并发

在IO密集型的情况下，使用协程能提高最高效率

协程作用：

　　手动实现 “遇到IO切换 + 保存状态” 来欺骗操作系统，让操作系统误以为没有IO操作，将CPU的执行权限给你

from gevent import monkey  # 猴子补丁
monkey.patch_all()  # 监听所有的任务是否有IO操作
from gevent import spawn  # spawn(任务)
from gevent import joinall
import time

def task1():
    print('start from task1...')
    time.sleep(1)
    print('end from task1...')

def task2():
    print('start from task2...')
    time.sleep(3)
    print('end from task2...')

def task3():
    print('start from task3...')
    time.sleep(5)
    print('end from task3...')


if __name__ == '__main__':

    start_time = time.time()
    sp1 = spawn(task1)
    sp2 = spawn(task2)
    sp3 = spawn(task3)
    # sp1.start()
    # sp2.start()
    # sp3.start()
    # sp1.join()
    # sp2.join()
    # sp3.join()
    joinall([sp1, sp2, sp3])

    end_time = time.time()

    print(f'消耗时间: {end_time - start_time}')