Python进程、线程、协程

进程

进程是指一个程序在给定数据集合上的一次执行过程，是系统进行资源分配和运行调用的独立单位。
可以简单地理解为操作系统中正在执行的程序。也就说，每个应用程序都有一个自己的进程。

每一个进程启动时都会最先产生一个唯一线程，即主线程，然后主线程会再创建其他的子线程。

线程

线程是一个基本的CPU执行单元。它必须依托于进程存活。一个线程是一个execution context（执行上下文），即一个CPU执行时所需要的一串指令。

协程

协程是一种用户态的轻量级线程，协程的调度完全由用户控制。
从技术的角度来说，“协程就是你可以暂停执行的函数”。协程拥有自己的寄存器上下文和栈。
协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销。
可以不加锁的访问全局变量，所以上下文的切换非常快。

进程和线程的区别

• 线程必须在某个进程中执行。
• 一个进程可包含多个线程，其中有且只有一个主线程。
• 多线程共享同个地址空间、打开的文件以及其他资源。
• 多进程共享物理内存、磁盘、打印机以及其他资源。
• 线程是处理器调度的基本单位,但进程不是

线程的类型

线程的因作用可以划分为不同的类型。大致可分为：

• 主线程
• 子线程
• 后台线程（守护线程）
• 前台线程

GIL（全局解释性锁）

其他语言，CPU是多核时是支持多个线程同时执行。但在Python中，无论是单核还是多核，同时只能由一个线程在执行。其根源是GIL的存在。GIL的全称是Global Interpreter Lock(全局解释器锁)，来源是Python设计之初的考虑，为了数据安全所做的决定。某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个Python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。

GIL只在CPython中才有，而在PyPy和Jython中是没有GIL的,CPython版本的解释器最常用。

并且由于GIL锁存在，Python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，Python 的多线程效率并不高的根本原因。

Python 对并发编程的支持

• 多线程：【threading】，利用CPU和IO同时执行的原理，让CPU不会干巴巴等待IO完成

• 多进程：【multiprocessing】，利用多核CPU的能力，真正的执行任务

• 异步IO：【asyncio】，在单线程利用CPU和IO同时执行的原理，实现函数异步执行

• 可以使用【Lock】对资源进行加锁，防止冲突

• 使用【Queue】实现不同线程/进程间的通信，实现生产者/消费者模式

• 使用线程池【ThreadPoolExecutor】/进程池【ProcessPoolExecutor】，简化线程/进程的任务提交、等待结束、获取结果

多进程、多线程、多协程的对比

一个进程开启的数量有限，这取决于CPU的限制

优点：可以利用多核CPU并行运算
缺点：占用资源最多，可以启动的数量比线程少
适用于：CPU密集型计算，例如：加解密、大数据、机器学习、正则表达式匹配等

一个进程中可以开启N个线程

优点：相比进程，更轻量，占用资源更少
缺点：
      - 相比进程：多线程只能并发执行，不能利用多CPU（GIL）
      - 相比协程：启动数目有限制，占用内存资源，有线程切换开销
适用于：I/O密集型计算，例如：api接口获取数据、爬虫、数据库或文件频繁读写等

一个线程可以开启N个协程，协程占用内存甚至只需要几Kb

优点：内存占用最小，启动数目最多
缺点：支持的库有限制，例如不能使用requtests，而要aiohttp或httpx，并且代码实现复杂
适用于：I/O密集型计算，需要超多任务执行，但有现成库支持的场景

如何选择使用合适的技术

1.首先判断任务类型，判断任务属于CPU密集型，还是IO密集型
2.如果任务属于CPU密集型 ==> 选择多进程
3.如果任务属于IO密集型：
                       - 判断任务是否需要超多的任务量，并且有现有协程库支持，并且可以接受其实现复杂度 ==> 选择多协程
                       - 否则 ==> 选择多线程

线程池使用的好处

提升性能：减去大量新建、终止线程的开销，重用了线程资源
适用场景：适合处理突发性大量请求或需要大量线程完成任务、但实际任务处理时间较短
防御功能：能有效避免系统创建线程过多，而导致系统负荷过大、变慢的问题
代码优势：使用线程池的语法，比自己创建执行线程更简洁

threading 和 multiprocessing对比

协程

在单线程内实现并发

核心原理1：用一个超级循环（实际上就是while...true循环）
核心原理2：配合IO多路复用原理（IO时CPU可以干其他事情）

信号量、旗语【Semaphore】

是一个同步对象，用于保持0到指定最大值之间的一个计数值，简而言之，用以控制并发量

简单案例

import aiohttp
import asyncio

loop = asyncio.get_event_loop()

# 当放开下面代码时，每次执行10个任务后会停下等待一会，当然，最终程序爬取完成时间会变长
# semaphore = asyncio.Semaphore(10)

async def async_crawl(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            result = await resp.text()
            await asyncio.sleep(5)
            print(f'请求地址：{url},{len(result)}')



if __name__ == '__main__':

    t1 = time.time()

    task_list = [loop.create_task(async_crawl(f'https://pic.netbian.com/index_{page}.html')) for page in range(50)]
    loop.run_until_complete(asyncio.wait(task_list))

    t2 = time.time()

    print(t2-t1)