爬虫高性能相关

Posted 2021-03-11 ghostant

前言

之前讨论过python中多线程和多进程的不同。

由于我们使用的python解释器是Cpython，并不是线程安全的，所以python解释器为了解决这个问题，引入了GIL全局解释器锁。这导致了在同一个进程(一个python解释器下)并不能真正的实现多线程的并行执行，在某一确定的时刻永远只有一个线程在运行。

由此我们可以讨论：

1.当一个程序是I/O密集型时，是该采用多线程还是应该采用多进程？

我们知道当程序进入I/O(阻塞态)时，操作系统会自动剥夺我们程序的CPU使用权。如果我们程序采用多进程，即使给我们的程序分配另外的cpu，操作系统一样会剥夺其对CPU的使用权，这就导致了虽然我们消耗了很多的资源，但几乎对程序的性能没有提升。所以我们应该采用多线程。

2.当一个程序是计算密集型时，是该采用多线程还是应该采用多进程？

计算任务总是由cpu执行，如果我们的计算密集型程序采用多线程，虽然各个计算任务好像在并发执行，但是单位时间内cpu的计算次数是几乎固定的。这就导致了，性能没有额外的提升还额外多了线程之间的切换所带来的开销。

一、同步、异步、回调机制

1.同步调用

import requests

def parse_page(res):
    print('解析 %s' %(len(res)))

def get_page(url):
    print('下载 %s' %url)
    response=requests.get(url)
    if response.status_code == 200:
        return response.text

urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']
for url in urls:
    res=get_page(url) #调用一个任务，就在原地等待任务结束拿到结果后才继续往后执行
    parse_page(res)

2.多线程或多进程

#IO密集型程序应该用多线程
import requests
from threading import Thread,current_thread

def parse_page(res):
    print('%s 解析 %s' %(current_thread().getName(),len(res)))

def get_page(url,callback=parse_page):
    print('%s 下载 %s' %(current_thread().getName(),url))
    response=requests.get(url)
    if response.status_code == 200:
        callback(response.text)

if __name__ == '__main__':
    urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']
    for url in urls:
        t=Thread(target=get_page,args=(url,))
        t.start()

#在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。

# 存在的问题
#开启多进程或都线程的方式，我们是无法无限制地开启多进程或多线程的：在遇到要同时响应成百上千路的连接请求，则无论多线程还是多进程都会严重占据系统资源，降低系统对外界响应效率，而且线程与进程本身也更容易进入假死状态。

3. 线程池或进程池+异步调用: 提交一个任务后并不会等待任务结束，而是继续下一行代码

#IO密集型程序应该用多线程，所以此时我们使用线程池
import requests
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def parse_page(res):
    res=res.result()
    print('%s 解析 %s' %(current_thread().getName(),len(res)))

def get_page(url):
    print('%s 下载 %s' %(current_thread().getName(),url))
    response=requests.get(url)
    if response.status_code == 200:
        return response.text

if __name__ == '__main__':
    urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']

?```
pool=ThreadPoolExecutor(50)
# pool=ProcessPoolExecutor(50)
for url in urls:
    pool.submit(get_page,url).add_done_callback(parse_page)

pool.shutdown(wait=True)

# 线程池旨在减少创建和销毁线程的频率，维持一定合理数量的进程，并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池，尽量重用已有的连接、减少创建和关闭连接的频率。这两种技术都可以很好的降低系统开销，都被广泛应用很多大型系统，如websphere、tomcat和各种数据库。

#存在的问题
# 线程池技术也只是在一定程度上缓解了频繁调用IO接口带来的资源占用。而且，所谓池是由上限的，当请求大大超过上限时，池构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池”必须考虑其面临的响应规模，并根据响应规模调整“池”的大小。

二、高性能

上述的无论哪种方案其实都没有解决一个性能相关的问题:I/O阻塞，无论是多进程还是多线程，在遇到I/O阻塞时都会被操作系统强行剥夺CPU的执行权限，程序执行的效率就降低了。

解决这一问题的关键在于，我们自己从应用程序级别检测I/O阻塞然后切换到我们自己程序的其他任务执行，这样把我们程序的I/O降到最低，我们的程序处于就绪态就会增多，以此来迷惑操作系统，操作系统会认为我们的程序是I/O比较少的程序，从而会尽可能的分配CPU。

1.asyncio模块

在python3.3后新增了asyncio模块，可以帮我们检测IO（只能是网络IO），实现应用程序级别的切换。

import asyncio

@asyncio.coroutine
def task(task_id,senconds):
    print('%s is start' %task_id)
    yield from asyncio.sleep(senconds) #只能检测网络IO,检测到IO后切换到其他任务执行
    print('%s is end' %task_id)

tasks=[task(task_id="任务1",senconds=3),task("任务2",2),task(task_id="任务3",senconds=1)]

loop=asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

但asyncio模块只能发tcp级别的请求，不能发http协议，因此，在我们需要发送http请求的时候，需要我们自定义http报头。

import asyncio
import requests
import uuid
user_agent='Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (Khtml, like Gecko) Chrome/49.0.2623.221 Safari/537.36 SE 2.X MetaSr 1.0'

def parse_page(host,res):
    print('%s 解析结果 %s' %(host,len(res)))
    with open('%s.html' %(uuid.uuid1()),'wb') as f:
        f.write(res)

@asyncio.coroutine
def get_page(host,port=80,url='/',callback=parse_page,ssl=False):
    print('下载 http://%s:%s%s' %(host,port,url))

?```
#步骤一（IO阻塞）：发起tcp链接，是阻塞操作，因此需要yield from
if ssl:
    port=443
recv,send=yield from asyncio.open_connection(host=host,port=443,ssl=ssl)

# 步骤二：封装http协议的报头，因为asyncio模块只能封装并发送tcp包，因此这一步需要我们自己封装http协议的包
request_headers="""GET %s HTTP/1.0
Host: %s
User-agent: %s

""" %(url,host,user_agent)
# requset_headers="""POST %s HTTP/1.0
Host: %s

name=egon&password=123""" % (url, host,)
request_headers=request_headers.encode('utf-8')

# 步骤三（IO阻塞）：发送http请求包
?```

    send.write(request_headers)
    yield from send.drain()

?```
# 步骤四（IO阻塞）：接收响应头
while True:
    line=yield from recv.readline()
    if line == b'
':
        break
    print('%s Response headers：%s' %(host,line))

# 步骤五（IO阻塞）：接收响应体
text=yield from recv.read()

# 步骤六：执行回调函数
?```

    callback(host,text)

?```
# 步骤七：关闭套接字
send.close() #没有recv.close()方法，因为是四次挥手断链接，双向链接的两端，一端发完数据后执行send.close()另外一端就被动地断开
?```

if __name__ == '__main__':
    tasks=[
        get_page('www.baidu.com',url='/s?wd=美女',ssl=True),
        get_page('www.cnblogs.com',url='/',ssl=True),
    ]

?```
loop=asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
?```

2.aiohttp模块

自定义报头非常麻烦，aiohttp模块帮我们封装了http报头，然后我们还需要asyncio检测IO实现切换。

import aiohttp
import asyncio

@asyncio.coroutine
def get_page(url):
    print('GET:%s' %url)
    response=yield from aiohttp.request('GET',url)

?```
data=yield from response.read()

print(url,data)
response.close()
return 1
?```

tasks=[
    get_page('https://www.python.org/doc'),
    get_page('https://www.cnblogs.com/linhaifeng'),
    get_page('https://www.openstack.org')
]

loop=asyncio.get_event_loop()
results=loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

print('=====>',results) #[1, 1, 1]

可以将requests.get函数传给asyncio，就能够被检测了

import requests
import asyncio

@asyncio.coroutine
def get_page(func,*args):
    print('GET:%s' %args[0])
    loog=asyncio.get_event_loop()
    furture=loop.run_in_executor(None,func,*args)
    response=yield from furture

?```
print(response.url,len(response.text))
return 1
?```

tasks=[
    get_page(requests.get,'https://www.python.org/doc'),
    get_page(requests.get,'https://www.cnblogs.com/linhaifeng'),
    get_page(requests.get,'https://www.openstack.org')
]

loop=asyncio.get_event_loop()
results=loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

print('=====>',results) #[1, 1, 1]

3.gevent模块

from gevent import monkey;monkey.patch_all()
import gevent
import requests

def get_page(url):
    print('GET:%s' %url)
    response=requests.get(url)
    print(url,len(response.text))
    return 1

# g1=gevent.spawn(get_page,'https://www.python.org/doc')
# g2=gevent.spawn(get_page,'https://www.cnblogs.com/linhaifeng')
# g3=gevent.spawn(get_page,'https://www.openstack.org')
# gevent.joinall([g1,g2,g3,])
# print(g1.value,g2.value,g3.value) #拿到返回值

#协程池
from gevent.pool import Pool
pool=Pool(2)
g1=pool.spawn(get_page,'https://www.python.org/doc')
g2=pool.spawn(get_page,'https://www.cnblogs.com/linhaifeng')
g3=pool.spawn(get_page,'https://www.openstack.org')
gevent.joinall([g1,g2,g3,])
print(g1.value,g2.value,g3.value) #拿到返回值

4.封装了gevent+requests的grequests模块

#pip3 install grequests

import grequests

request_list=[
    grequests.get('https://wwww.xxxx.org/doc1'),
    grequests.get('https://www.cnblogs.com/linhaifeng'),
    grequests.get('https://www.openstack.org')
]

##### 执行并获取响应列表 #####
# response_list = grequests.map(request_list)
# print(response_list)

##### 执行并获取响应列表（处理异常） #####
def exception_handler(request, exception):
    # print(request,exception)
    print("%s Request failed" %request.url)

response_list = grequests.map(request_list, exception_handler=exception_handler)
print(response_list)

grequests

5.twisted是一个网络框架，其中一个功能是发送异步请求，并自动检测IO切换。

'''
#问题一：error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++ Build Tools": http://landinghub.visualstudio.com/visual-cpp-build-tools
https://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
pip3 install C:UsersAdministratorDownloadsTwisted-17.9.0-cp36-cp36m-win_amd64.whl
pip3 install twisted

#问题二：ModuleNotFoundError: No module named 'win32api'
https://sourceforge.net/projects/pywin32/files/pywin32/

#问题三：openssl
pip3 install pyopenssl
'''

#twisted基本用法
from twisted.web.client import getPage,defer
from twisted.internet import reactor

def all_done(arg):
    # print(arg)
    reactor.stop()

def callback(res):
    print(res)
    return 1

defer_list=[]
urls=[
    'http://www.baidu.com',
    'http://www.bing.com',
    'https://www.python.org',
]
for url in urls:
    obj=getPage(url.encode('utf=-8'),)
    obj.addCallback(callback)
    defer_list.append(obj)

defer.DeferredList(defer_list).addBoth(all_done)

reactor.run()



#twisted的getPage的详细用法
from twisted.internet import reactor
from twisted.web.client import getPage
import urllib.parse

def one_done(arg):
    print(arg)
    reactor.stop()

post_data = urllib.parse.urlencode({'check_data': 'adf'})
post_data = bytes(post_data, encoding='utf8')
headers = {b'Content-Type': b'application/x-www-form-urlencoded'}
response = getPage(bytes('http://dig.chouti.com/login', encoding='utf8'),
                   method=bytes('POST', encoding='utf8'),
                   postdata=post_data,
                   cookies={},
                   headers=headers)
response.addBoth(one_done)

reactor.run()

6.tornado

from tornado.httpclient import AsyncHTTPClient
from tornado.httpclient import HTTPRequest
from tornado import ioloop



def handle_response(response):
    """
    处理返回值内容（需要维护计数器，来停止IO循环），调用 ioloop.IOLoop.current().stop()
    :param response:
    :return:
    """
    if response.error:
        print("Error:", response.error)
    else:
        print(response.body)

def func():
    url_list = [
        'http://www.baidu.com',
        'http://www.bing.com',
    ]
    for url in url_list:
        print(url)
        http_client = AsyncHTTPClient()
        http_client.fetch(HTTPRequest(url), handle_response)

ioloop.IOLoop.current().add_callback(func)
ioloop.IOLoop.current().start()



#发现上例在所有任务都完毕后也不能正常结束，为了解决该问题，让我们来加上计数器
from tornado.httpclient import AsyncHTTPClient
from tornado.httpclient import HTTPRequest
from tornado import ioloop

count=0

def handle_response(response):
    """
    处理返回值内容（需要维护计数器，来停止IO循环），调用 ioloop.IOLoop.current().stop()
    :param response:
    :return:
    """
    if response.error:
        print("Error:", response.error)
    else:
        print(len(response.body))

?```
global count
count-=1 #完成一次回调，计数减1
if count == 0:
    ioloop.IOLoop.current().stop() 
?```

def func():
    url_list = [
        'http://www.baidu.com',
        'http://www.bing.com',
    ]

?```
global count
for url in url_list:
    print(url)
    http_client = AsyncHTTPClient()
    http_client.fetch(HTTPRequest(url), handle_response)
    count+=1 #计数加1
?```


ioloop.IOLoop.current().add_callback(func)
ioloop.IOLoop.current().start()