单进程单线程爬取目标网站太过缓慢，这个只是针对新手来说非常友好，只适合爬取小规模项目，如果遇到大型项目就不得不考虑多线程、线程池、进程池以及协程等问题。那么我们该如何提升工作效率降低成本？

学习之前首先要对线程，进程，协程做一个简单的区分吧：

进程是资源单位，每一个进程至少要有一个线程，每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。

线程是执行单位，启动每一个程序默认都会有一个主线程。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。

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

了解了进程、线程、协程之间的区别之后，我们就可以思考如何用这些东西来提高爬虫的效率呢？

提高爬虫效率的方法

多线程

要体现多线程的特点就必须得拿单线程来做一个比较，这样才能凸显不同~

单线程运行举例：

 def func():
     for i in range(5):
         print("func", i)


 if __name__ == '__main__':
     func()
     for i in range(5):
         print("main", i)

运行结果如下：

# 单线程演示案例

result：
func 0
func 1
func 2
func 3
func 4
main 0
main 1
main 2
main 3
main 4

可以注意到在单线程的情况下，程序是先打印fun 0 - 4， 再打印main 0 - 4。

下面再举一个多线程的例子：

需要实例化一个Thread类 Thread(target=func()) target接收的就是任务（/函数），通过.start()方法就可以启动多线程了。

代码提供两种方式：

# 多线程（两种方法）
# 方法一：
 from threading import Thread

 def func():
     for i in range(1000):
         print("func ", i)

 if __name__ == '__main__':
     t = Thread(target=func())  # 创建线程并给线程安排任务
     t.start()  # 多线程状态为可以开始工作状态，具体的执行时间由CPU决定  
     for i in range(1000):
         print("main ", i)

# two
class MyThread(Thread):
    def run(self): # 固定的  -> 当线程被执行的时候，被执行的就是run()
        for i in range(1000):
            print("子线程 ", i)


if __name__ == '__main__':
    t = MyThread()
    # t.run()  #方法调用 --》单线程
    t.start()  #开启线程
    for i in range(1000):
        print("主线程 ", i)

运行结果

子线程和主线程有时候会同时执行，这就是多线程吧。

线程创建之后只是代表处于能够工作的状态，并不代表立即执行，具体执行的时间需要看CPU。

感觉线程执行的顺序就是杂乱无章的。

接下来分享一下多进程：

多进程

进程的使用：Process(target=func())

先举一个例子来感受一下多进程的执行顺序：

from multiprocessing import Process

def func():
    for i in range(1000):
        print("子进程 ", i)

if __name__ == '__main__':
    p = Process(target=func())
    p.start()
    for i in range(1000):
        print("主进程 ", i)

运行结果：

从结果中可以发出，所有的子进程按照顺序执行之后。就开始打印主进程0-999。进程打印的有序也表明线程是最小的执行单位。

开启多线程打印的时候，出现的数字并不是有序的。

线程池&进程池

在python中一般使用以下方法创建线程池/进程池：

with ThreadPoolExecutor(50) as t:
     t.submit(fn, name=f"线程{i}")

具体代码：

# 线程池：一次性开辟一些线程，我们用户直接给线程池提交任务，线程任务的调度交给线程池来完成
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

def fn(name):
    for i in range(1000):
        print(name,i)

if __name__ == '__main__':
    # 创建线程池
    with ThreadPoolExecutor(50) as t:
        for i in range(100):
            t.submit(fn, name=f"线程{i}")
    # 等待线程池中的任务全部执行完毕，才继续执行（守护）
    print(123)

进程池的创建方法类似。

协程

协程：当程序遇见IO操作的时候，可以选择性的切换到其他任务上。

在微观上是一个任务一个任务的进行切换，切换条件一般就是IO操作。

在宏观上，我们能看到的其实就是多个任务一起在执行。

多任务异步操作（就像你自己一边洗脚一边看剧一样~，时间管理带师(bushi）。

线程阻塞的一些案例：

例子1：

time.sleep(30)    # 让当前线程处于阻塞状态，CPU是不为我工作的
# input()    程序也是处于阻塞状态
# requests.get(xxxxxx) 在网络请求返回数据之前，程序也是处于阻塞状态
# 一般情况下，当程序处于IO操作的时候，线程都会处于阻塞状态
# for example： 边洗脚边按摩

import asyncio
import time

async def func():
     print("hahha")

if __name__ == "__main__":
     g = func()  # 此时的函数是异步协程函数，此时函数执行得到的是一个协程对象
     asyncio.run(g) # 协程程序运行需要asyncio模块的支持

输出结果：

root@VM-12-2-ubuntu:~/WorkSpace# python test.py
hahha

例子2：

async def func1():
     print("hello，my name id hanmeimei")
     # time.sleep(3)  # 当程序出现了同步操作的时候，异步就中断了
     await asyncio.sleep(3)  # 异步操作的代码
     print("hello，my name id hanmeimei")


 async def func2():
     print("hello，my name id wahahha")
     # time.sleep(2)
     await asyncio.sleep(2)  # 异步操作的代码
     print("hello，my name id wahahha")


 async def func3():
     print("hello，my name id hhhhhhhc")
     # time.sleep(4)
     await asyncio.sleep(4)  # 异步操作的代码
     print("hello，my name id hhhhhhhc")


 if __name__ == "__main__":
     f1 = func1()
     f2 = func2()
     f3 = func3()
     task = [
         f1, f2, f3
     ]
     t1 = time.time()
     asyncio.run(asyncio.wait(task))
     t2 = time.time()
     print(t2 - t1)

运行结果：

注意到执行await asyncio.sleep(4)后，主程序就会调用其他函数了。成功实现了异步操作。（边洗脚边按摩bushi ）

下面的代码看起来更为规范~

async def func1():
    print("hello，my name id hanmeimei")
    await asyncio.sleep(3)
    print("hello，my name id hanmeimei")


async def func2():
    print("hello，my name id wahahha")
    await asyncio.sleep(2)
    print("hello，my name id wahahha")


async def func3():
    print("hello，my name id hhhhhhhc")
    await asyncio.sleep(4)
    print("hello，my name id hhhhhhhc")


async def main():
    # 第一种写法
    # f1 = func1()
    # await f1 # 一般await挂起操作放在协程对象前面
    # 第二种写法(推荐)
    tasks = [
        func1(),   # py3.8以后加上asyncio.create_task()
        func2(),
        func3()
    ]
    await asyncio.wait(tasks)


if __name__ == "__main__":
    t1 = time.time()
    asyncio.run(main())
    t2 = time.time()
    print(t2 - t1)

再举一个模拟下载的例子吧，更加形象啦：

async def download(url):
    print("准备开始下载")
    await asyncio.sleep(2) # 网络请求
    print("下载完成")

async def main():
    urls = [
        "http://www.baidu.com",
        "http://www.bilibili.com",
        "http://www.163.com"
    ]
    tasks = []
    for url in urls:
        d = download(url)
        tasks.append(d)

    await asyncio.wait(tasks)

if __name__ == '__main__':
    asyncio.run(main())

# requests.get()  同步的代码 => 异步操作aiohttp

import asyncio
import aiohttp

urls = [
    "http://kr.shanghai-jiuxin.com/file/2020/1031/191468637cab2f0206f7d1d9b175ac81.jpg",
    "http://i1.shaodiyejin.com/uploads/tu/201704/9999/fd3ad7b47d.jpg",
    "http://kr.shanghai-jiuxin.com/file/2021/1022/ef72bc5f337ca82f9d36eca2372683b3.jpg"
]


async def aiodownload(url):
    name = url.rsplit("/", 1)[1]  # 从右边切，切一次，得到[1]位置的内容 fd3ad7b47d.jpg
    async with aiohttp.ClientSession() as session: # requests
        async with session.get(url) as resp: # resp = requests.get()
            # 请求回来之后，写入文件
            # 模块 aiofiles
            with open(name, mode="wb") as f: # 创建文件
                f.write(await resp.content.read())  # 读取内容是异步的，需要将await挂起, resp.text()
    print(name, "okk")
            # resp.content.read() ==> resp.text()
    # s = aiphttp.ClientSession <==> requests
    # requests.get()  .post()
    # s.get()  .post()
    # 发送请求
    # 保存图片内容平
    # 保存为文件


async def main():
    tasks = []
    for url in urls:
        tasks.append(aiodownload(url))
    await asyncio.wait(tasks)


if __name__ == '__main__':
    asyncio.run(main())