GIL和池的概念

1.GIL概念

1. 什么是GIL(为Cpython解释器)
    GIL本身就是一把互斥锁. 原理都一样. 都是让并发的线程同一时间只能执行一个
    所以有了GIL的存在. 同一进程下的多个线程同一时刻只能有一个能运行. 无法实现并行 -> 意味着无法利用多核优势 -> 多个CPU同时计算
    GIL是影响python运行效率慢的原因之一. 但是不影响并发的执行. 只是无法同时利用多个cpu执行计算

    GIL可以被比喻成执行权限. 同一进程下的所有线程要想运行代码都要先抢执行权限

2. 为何要有GIL:
    因为Cpython中自带的垃圾回收机制不是线程安全的 -> 需要将GIL锁加在Cpython之上. 控制只能有一个线程在执行.
                                             抢到GIL才能去执行

3. 如果使用:
    GIL vs 自定义的互斥锁
        GIL相当于执行任务. 会在任务无法执行时. 被强迫释放
        自定义互斥锁. 即便是无法执行. 也不回自动释放

4. 多线程执行IO密集型任务会大幅提升效率: 多线程发送网络请求
    执行CPU密集型任务反而会降低效率. 因为频繁切换切换线程导致无意义的时间消耗.产生CPU颠簸. CPU负责计算.程序出现io什么都做不了

    CPU密集型任务可以使用多进程并发

5. 多线程的并发运行:
    每个线程都要先执行请求GIL. 当线程阻塞时(例如IO阻塞). 线程释放GIL. 这时另外一个线程开始运行
    操作系统将时间分成多个时间片去运行线程. 线程之间切换速度极快. 肉眼看起来就行是同时运行. 其实并不是同时运行
    所以多线程只是并发. 看起来同时运行. 并非并行

2.线程queue

# -*- encoding:utf-8 -*-
# @time: 2022/8/7 16:10
# @author: Maxs_hu
import queue

# 队列: 先进先出
q = queue.Queue(5)
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())

# 堆栈: 先进后出
q = queue.LifoQueue(5)  # last in first out
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())

# 优先级队列: 数字越小. 优先级越高
q = queue.PriorityQueue()
q.put((-1, 'data1'))
q.put((11, 'data2'))
q.put((200, 'data3'))
print(q.get())
print(q.get())
print(q.get())

# (-1, 'data1')
# (11, 'data2')
# (200, 'data3')

3.线程池

"""
1. 什么时候用池:
    池的功能是限制启动的进程数量或线程数
    什么时候应该限制？？？
        当并发任务数远远超过了计算机承受能力时. 即无法一次性开启过多的进程数或线程数
        就应该用池的概念将开启的进程数或者线程数限制在计算机可承受的范围内

2. 同步vs异步
    同步和异步是提交任务的两种方式
    同步: 类似于串行. 任务提交后等待返回值返回. 再提交下一个任务(和异步对比...基本不用)
    异步: 提交完任务后不会在原地等待. 直接运行下一行代码. 等到任务有返回值后会自动触发回调函数
"""

from concurrent.futures import ThreadPoolExecutor  # 线程池启动器  concurrent 能够同时发生的
import time

# =====程序无返回值时=====
def func(name):
    for i in range(10):
        print(name, i)

if __name__ == '__main__':
    with ThreadPoolExecutor(9) as t:
        # 直接将三百个submit提交给线程池
        for i in range(100):
            t.submit(func, "周杰伦")  # submit 提交
            t.submit(func, "薛之谦")
            t.submit(func, "林俊杰")

# =====程序有返回值时，且需要输出返回值时=====

def func(name, t):
    time.sleep(t)
    print(f"我叫{name}")
    return name

def parse(res):
    print(res.result())  # 注意要加括号

if __name__ == '__main__':
    with ThreadPoolExecutor(3) as t:
        t.submit(func, "薛之谦", 3).add_done_callback(parse)  # callback返回即执行，但执行顺序是不确定的
        t.submit(func, "许嵩", 2).add_done_callback(parse)  # 这里自动执行，参数也是自动传递
        t.submit(func, "林俊杰", 1).add_done_callback(parse)

# =====执行顺序确定的线程池=====

def func(name, t):
    time.sleep(t)
    print(f"my name is {name}")
    return name

if __name__ == '__main__':
    with ThreadPoolExecutor(3) as t:
        result = t.map(func, ["薛之谦", "林俊杰", "许嵩"], [2, 1, 3])  # map 映射
        for res in result:
            print(res)  # 返回值有特点，是因为多线程较快
        # map的返回值是迭代器
        # 打印的结果是有序的，且按照分配任务的顺序进行打印

4.进程池

# -*- encoding:utf-8 -*-
# @time: 2022/8/7 21:27
# @author: Maxs_hu

# 调用进程池(无返回值):
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import os
import time

def task(i):
    print('%s is running %s' % (os.getpid(), i))
    time.sleep(2)

if __name__ == '__main__':
    with ProcessPoolExecutor(4) as p:  # 创建进程池最多并发四个进程
        for i in range(10):  # 将9个任务交给进程池执行
            p.submit(task, i)  # 任务提交

# 进程池(有返回值) -> 返回值无序. 如果想要返回值有序. 则需要使用map函数提交任务
def task(i):
    print('%s is running %s' % (os.getpid(), i))
    time.sleep(2)
    return i ** 2

def parse(res):
    print(res.result())

if __name__ == '__main__':
    with ProcessPoolExecutor(4) as p:
        for i in range(10):
            p.submit(task, i).add_done_callback(parse)  # 任务提交之后出现返回值就会执行回调函数执行parse. 打印返回值
            p.submit(task, i).add_done_callback(parse)