正文

Web 请求之--性能相关

IP云
IP云V管理员/0 阅读
09/10
小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

本博客代码运行环境

python : Python 3.7.1rc1 version
pip : pip 19.1.1 version
Scrapy: scrapy 1.6.0 version
asyncio: asyncio 3.4.3 version
aiohttp: aiohttp 3.5.4 version
gevent: gevent 1.4.0 version
grequests: grequests 0.3.0 version
greenlet: greenlet 0.4.15 version
requests: requests 2.21.0 version
urllib3: urllib3 1.24.1 version
tornado: tornado 6.0.2 version
twisted: twisted 19.2.0 version

以下所有代码都以 爬虫 为例， 发送 http 请求，获取页面源码。

概念回顾

操作系统(OS)：
是一个用来协调、管理和控制计算机硬件和软件资源的系统程序，它位于硬件和应用程序之间。

进程(Process)：------------》》是 OS 进行资源分配和调度的一个基本独立单位
进程就是一个程序在一个数据集上的一次动态执行过程。
进程一般由程序、数据集、进程控制块三部分组成。
程序: 由我们编写用来描述进程要完成哪些功能以及如何完成，是指令、数据及其组织形式的描述，进程是程序的实体
数据集: 则是程序在执行过程中所需要使用的资源；
进程控制块： 用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。
多进程：
指操作系统能同时运行多个任务（程序）。
总结来说：
进程是线程的容器
每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位
适用于： 计算密集型

线程(Thread):------------》》是cpu调度和分派的最小单位
有时被称为轻量级进程(Lightweight Process，LWP)
为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，使到进程内并发成为可能。
是程序执行流的最小单元。 一个标准的线程由线程ID，当前指令指针(PC)，寄存器集合和堆栈组成
线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。
一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。
由于线程之间的相互制约，致使线程在运行中呈现出间断性。
线程也有就绪、阻塞和运行三种基本状态：
就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待 CPU 调度;
阻塞状态是指线程在等待一个事件(如某个信号量)，逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。
运行状态是指线程占有 CPU 正在运行;
多线程：
在单个程序中同时运行多个线程完成不同的工作，即具有多个顺序流在执行。
总结来说：
线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。
同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）
适用于： IO 密集型
GIL全局解释器锁（Global Interpreter Lock):
无论你启多少个线程，你有多少个cpu, Python在执行一个进程的时候会淡定的在同一时刻只允许一个线程运行
机制，一个基本的要求就是需要实现不同线程对共享资源访问的互斥，所以引入了GIL。
GIL缺点：多处理器退化为单处理器；优点：避免大量的加锁解锁操作
协程(Coroutine)：
又称微线程，纤程。协程是一种用户态的轻量级线程。
线程/进程:操作系统提供的一种并发处理任务的能力,操作是由程序触发系统接口， 操作者：系统；
协程：程序员通过高超的代码能力，在代码执行流程中人为的实现多任务并发，是单个线程内的任务调度技巧。操作者：程序员；
没有切换的开销。协程不需要多线程的锁机制，因为都是在同一个线程中运行，所以没有同时访问数据的问题，执行效率比多线程高很多
协程存在的意义：对于多线程应用，CPU通过切片(轮询)的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。
协程切换时，因为只使用一个线程，是由程序自身控制的，体现的是程序员的流程控制能力，通过一定的语法规定在一个线程中所有代码块的执行顺序。
协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程， 即： IO 密集型综上： 最佳方案： 协程 + 多进程

线程与进程的共同点和区别

(1）共同点： 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。(2)区别： 线程和进程的区别在于，子进程和父进程有不同的代码和数据空间，而多个线程则共享数据空间，每个线程有自己的执行堆栈和程序计数器为其执行上下文。多线程主要是为了充分利用 CPU，提高效率。
线程与进程的区别可以归纳为以下几点：
1）地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。2）通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。3）调度和切换：线程上下文切换比进程上下文切换要快得多。故所消耗的资源比进程要少的多多。4）在多线程OS中，进程不是一个可执行的实体。
(3)线程的属性(特点)：
1)轻型实体
线程中的实体基本上不拥有系统资源，只是有一点必不可少的、能保证独立运行的资源，比如:
在每个线程中都具有一个用于控制线程运行的线程控制块TCB，用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。2)独立调度和分派的基本单位。
在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。由于线程很“轻”，故线程的切换非常迅速且开销小。3)可并发执行。
在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行。4)共享进程资源。
在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：
所有线程都具有相同的地址空间（进程的地址空间），这意味着，线程可以访问该地址空间的每一个虚地址；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。

HTTP 协议

HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。HTTP是一个属于应用层的面向对象的协议,目前在WWW中使用的是 HTTP/1.0的第六版，HTTP协议工作于客户端-服务端架构为上。基于 ： 请求-----响应 ，模式

HTTP 特点

1、简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。
每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。2、灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。3.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。4.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。
缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

HTTP 协议 数据发送格式

HTTP 请求协议

请求首行； // 请求方式 请求路径 协议和版本，例如：GET /index.html HTTP/1.1
请求头信息； // 请求头名称:请求头内容，即为key:value格式，例如：Host:localhost
空行； // 用与分隔 请求头 和 请求体(\r\n\r\n)
请求体。 // GET没有请求体，只有POST有请求体。

GET:
HTTP默认的请求方法就是GET
      * 没有请求体
      * 数据量有限制！
      * GET请求数据会暴露在浏览器的地址栏中
GET请求常用的操作：
       1. 在浏览器的地址栏中直接给出URL，那么就一定是GET请求
       2. 点击页面上的超链接也一定是GET请求
       3. 提交表单时，表单默认使用GET请求，但可以设置为POST
例如：
GET 请求：
GET /338.jpg HTTP/1.1\r\nHost:img.mukewang.com\r\nContent-Type:multipart/form-data\r\nReferer:http://www.imooc.com/\r\n\r\n
POST 请求：
POST / HTTP/1.1\r\nHost: img.mukewang.com\r\nConnection: Keep-Alive\r\n\r\nname=Professional&publisher=Wiley

请求头：

1、Host请求的web服务器域名地址2、User-AgentHTTP客户端运行的浏览器类型的详细信息。通过该头部信息，web服务器可以判断出http请求的客户端的浏览器的类型。3、Accept指定客户端能够接收的内容类型，内容类型的先后次序表示客户都接收的先后次序4、Accept-Lanuage指定HTTP客户端浏览器用来展示返回信息优先选择的语言5、Accept-Encoding指定客户端浏览器可以支持的web服务器返回内容压缩编码类型。表示允许服务器在将输出内容发送到客户端以前进行压缩，以节约带宽。
而这里设置的就是客户端浏览器所能够支持的返回压缩格式。6、Accept-CharsetHTTP客户端浏览器可以接受的字符编码集7、Content-Type显示此HTTP请求提交的内容类型。一般只有post提交时才需要设置该属性有关Content-Type属性值有如下两种编码类型：（1）“application/x-www-form-urlencoded”： 表单数据向服务器提交时所采用的编码类型，默认的缺省值就是“application/x-www-form-urlencoded”。
然而，在向服务器发送大量的文本、包含非ASCII字符的文本或二进制数据时这种编码方式效率很低。（2）“multipart/form-data”： 在文件上载时，所使用的编码类型应当是“multipart/form-data”，它既可以发送文本数据，也支持二进制数据上载。当提交为表单数据时，可以使用“application/x-www-form-urlencoded”；当提交的是文件时，就需要使用“multipart/form-data”编码类型。

HTTP 响应协议

HTTP响应也由四个部分组成，分别是：状态行、消息报头、空行和响应正文。
例如：

HTTP/1.1 200 OK
Date: Fri, 22 May 2009 06:07:21 GMT
Content-Type: text/html; charset=UTF-8 <html>
<head></head>
<body>
<!--body goes here-->
</body>
</html>

例：

HTTP/1.1 200 OK\r\nDate：Fri, 22 May 2009 06:07:21 GMT\r\nContent-Type： text/html; charset=UTF-8\r\n\r\n<html><head</head><body>shiwei</body></html>

第一部分：状态行，由HTTP协议版本号， 状态码， 状态消息 三部分组成。

第一行为状态行，（HTTP/1.1）表明HTTP版本为1.1版本，状态码为200，状态消息为（ok）

第二部分：消息报头，用来说明客户端要使用的一些附加信息

第二行和第三行为消息报头，
              Date:生成响应的日期和时间；Content-Type:指定了MIME类型的HTML(text/html),编码类型是UTF-8

第三部分：空行，消息报头后面的空行是必须的
第四部分：响应正文，服务器返回给客户端的文本信息。

响应状态码：

状态代码有三位数字组成，第一个数字定义了响应的类别，共分五种类别:
1xx：指示信息--表示请求已接收，继续处理
2xx：成功--表示请求已被成功接收、理解、接受
3xx：重定向--要完成请求必须进行更进一步的操作
4xx：客户端错误--请求有语法错误或请求无法实现
5xx：服务器端错误--服务器未能实现合法的请求
常见状态码：
200 OK //客户端请求成功
400 Bad Request //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用
403 Forbidden //服务器收到请求，但是拒绝提供服务
404 Not Found //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常

准备好了吗？基础知识很重要！！

编写爬虫程序，性能的消耗主要在 IO 请求中，当单进程单线程模式下请求URL时必然会引起等待，效率极低！

import requests def task(url):
response = requests.get(url)
return response url_list = ['http://www.github.com', 'http://www.bing.com'] for url in url_list:
task(url)

同步执行

from concurrent.futures import ThreadPoolExecutor
import requests def task(url):
response = requests.get(url)
print(response)
# print(response.text) # 获取 页面 源码 字符串数据
print("\033[1;30;47murl==%-70s----------response==%-s\033[0m"%(url,response.status_code))
return response url_list = [
"http://tuijian.hao123.com/",
"http://www.163.com/",
"http://www.eastmoney.com/",
] pool = ThreadPoolExecutor(5) for url in url_list:
v = pool.submit(task,url) pool.shutdown(wait=True)

多线程执行

from concurrent.futures import ThreadPoolExecutor
import requestsdef task(url):
""" 返回页面 源码数据 """
response = requests.get(url)
print("\033[1;30;47murl==%-70s----------response==%-s\033[0m"%(url,response.status_code))
return responsedef done(future,*args, **kwargs):
""" 解析页面 源码 """
print(future.result())url_list = [
"http://tuijian.hao123.com/",
"http://www.163.com/",
"http://www.eastmoney.com/",
]pool = ThreadPoolExecutor(5)for url in url_list:
v = pool.submit(task,url)
v.add_done_callback(done)pool.shutdown(wait=True)

多线程 + 回调函数 

from concurrent.futures import ProcessPoolExecutor
import requestspool = ProcessPoolExecutor(5)
def task(url):
response = requests.get(url)
print(response)
print("\033[1;30;47murl==%-70s----------response==%-s\033[0m"%(url,response.status_code))
return responseurl_list = [
"http://tuijian.hao123.com/",
"http://www.163.com/",
"http://www.eastmoney.com/",
]if __name__ == "__main__": # 必须要加 此 判断语句
for url in url_list:
v = pool.submit(task, url)pool.shutdown(wait=True)

多进程执行

from concurrent.futures import ProcessPoolExecutor
import requests
pool = ProcessPoolExecutor(5)def task(url):
response = requests.get(url)
# print("\033[1;30;47murl==%-70s----------response==%-s\033[0m"%(url,response.status_code))
return responsedef done(*args, **kwargs):
print(args[0].result())
print("\033[1;31;40m %s-----%s \033[0m"%(args, kwargs))
url_list = [
"http://tuijian.hao123.com/",
"http://www.163.com/",
"http://www.eastmoney.com/",
]if __name__ == "__main__": # 必须要加 此 判断语句
for url in url_list:
v = pool.submit(task, url)
v.add_done_callback(done)pool.shutdown(wait=True)

多进程 + 回调函数

以上代码 均 可提升请求性能， 但多线程 和 多进程 的缺点是 在 IO 阻塞时 依然会造成线程 和 进程的 浪费，

故 异步 IO   是 首选:

遇到 IO , 则 立即转而操作其他， IO 完成时，则自动回调运行处理 IO 的 函数。

import asyncio
# 不支持 HTTP 请求， 但支持 tcp 请求，socket
@asyncio.coroutine # 不可缺少
def task():
print('before ......Task')
yield from asyncio.sleep(5) # 不可写为 time.sleep(5)
print('after ...... Task')tasks = [task(), task(), task()] # 任务列表
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

asyncio 示例

asyncio + 模拟 http :

import asyncio
@asyncio.coroutine
def task(host,url='/'):
# 创建 链接
reader, writer = yield from asyncio.open_connection(host, 80) request_header_content = """GET %s HTTP/1.0\r\nHost: %s\r\n\r\n"""%(url,host,)
request_header_content = bytes(request_header_content, encoding='utf-8') writer.write(request_header_content)
yield from writer.drain()
text = yield from reader.read()
print('ending ',host, url, text)
writer.close()tasks = [
task('www.cnblogs.com', '/wupeiqi/'),
task('www.cnblogs.com', '/shiwei1930/'),
task('www.cnblogs.com', '/alex3714/'),
]loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

asyncio  + aiohttp :

import aiohttp
import asyncio@asyncio.coroutine
def task(url):
print(url)
resp = aiohttp.ClientSession().get(url)
response = yield from resp
print(url, response)
response.close()tasks = [task('http://www.baidu.com/'), task('http://www.chouti.com/')]loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

asyncio + requests

import requests
import asyncio
@asyncio.coroutine
def task(func,*args):
loop = asyncio.get_event_loop()
future = loop.run_in_executor(None,func,*args)
response = yield from future
print('\033[1;31;40m url=%-30s\n\033[0mcontents=%-30s'%(response.url,response.content))tasks = [
task(requests.get, 'http://www.baidu.com/'),
task(requests.get, 'http://www.cnblogs.com/'),
task(requests.get, 'http://autohome.com.cn'),
]loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(*tasks))
print(results)
loop.close()

gevent + requests

import requests
import gevent
from gevent import monkey
monkey.patch_all() # 不可缺少def task(method,url,req_kwargs):
print('method=%s,url=%s,kwargs=%s'%(method,url,req_kwargs))
response = requests.request(method=method,url=url, **req_kwargs)
print('url=%s\n\t\tcontent=%s'%(response.url,response.content))gevent.joinall([
gevent.spawn(task,method='get', url='https://www.github.com/', req_kwargs={}),
gevent.spawn(task, method='get', url='https://www.yahoo.com/', req_kwargs={}),
gevent.spawn(task, method='get', url='https://www.python.org/', req_kwargs={}),
])

grequests  =    gevent + requests

import grequestsrequest_list = [
grequests.get('http://www.cnblogs.com/'),
grequests.get('https://www.yahoo.com/'),
grequests.get('https://www.github.com/'),
]response_list = grequests.map(request_list)
print('result=',response_list)
for item in response_list:
print('content=',item.content)

Twisted

from twisted.web.client import getPage,defer
from twisted.internet import reactordef callback(contents):
print(contents)def all_done(arg):
reactor.stop() # 全部完成之后 stop@defer.inlineCallbacks
def task(url):
defered = getPage(bytes(url, encoding='utf8'))
defered.addCallback(callback)
yield defered
defered_list = []url_list = ['http://www.cnblogs.com/', 'https://github.com/', 'http://baidu.com/']
for url in url_list:
defered = task(url)
defered_list.append(defered)dlist = defer.DeferredList(defered_list)
dlist.addBoth(all_done)# 事件循环
reactor.run() # 去 defered_list 中 检测 谁回来了， 是个死 循环

Tornado

from tornado.httpclient import AsyncHTTPClient
from tornado.httpclient import HTTPRequest
from tornado import ioloopCOUNT = 0
def handler_response(response):
global COUNT
COUNT -= 1
if response.error:
print('error:',response.error)
else:
print('body:',response.body)
if COUNT == 0:
ioloop.IOLoop.current().stop()def task():
url_list = [
'http://www.baidu.com/',
'http://www.cnblogs.com/',
'https://www.github.com',
]
global COUNT
COUNT = len(url_list)
for url in url_list:
print("url===",url)
http_client = AsyncHTTPClient()
http_client.fetch(HTTPRequest(url),handler_response)
if __name__ == '__main__':
ioloop.IOLoop.current().add_callback(task)
ioloop.IOLoop.current().start() # # 事件循环， 是一个 死循环

自定义 异步 IO 框架

最基本的 网络编程的 本质：客户端

import socket
sk = socket.socket()
# 链接
sk.connect(('www.baidu.com',80)) # IO 阻塞# 设置 非阻塞
# sk.setblocking(False) # 请求是 发过去了print('链接成功！')sk.send(b'GET / HTTP/1.0\r\nHost: baidu.com\r\n\r\n')
# sk.send(b'POST / HTTP/1.0\r\nHost: baidu.com\r\n\r\n fdkfjdkjfkdfj')buffer_size = 1024
# 等待 着 服务端响应
data = sk.recv(buffer_size) # IO 阻塞print(data)
# 关闭链接
sk.close()

自定义 异步 IO 框架-----》客户端

import select
import socket# IO 多路复用： 监听多个 Socket 对象 ，死循环， 事件循环
# - 利用此特性 可以开发 异步 IO 模块 等等# 异步 IO : 遇到 IO , 则 立即转而操作其他， IO 返回时，则自动回调处理 IO 的 函数。
# 回答： 非阻塞的 socket(setblocking(False)) + IO 多路复用# 此时 为客户端
class HttpRequest:
def __init__(self, sk, host, callback):
self.socket = sk
self.host = host
self.callback = callback
def fileno(self):
return self.socket.fileno()Buffer_size = 4096class HttpResponse:
def __init__(self, recv_data):
self.recv_data = recv_data
self.header_dict = {}
self.body = ""
self.initialize() def initialize(self):
headers, body = self.recv_data.split(b'\r\n\r\n', 1)
header_list = headers.split(b'\r\n')
for item in header_list:
item_str = str(item, encoding='utf-8')
sp = item_str.split(':', 1)
if len(sp) == 2:
self.header_dict[sp[0]] = sp[1]class AsyncRequest:
def __init__(self):
self.conn = []
self.connection = [] # 用于检测 是否链接成功 def add_request(self, host,callback):
try:
sk = socket.socket()
sk.setblocking(False)
sk.connect((host, 80))
except BlockingIOError as e:
pass
request = HttpRequest(sk, host, callback)
self.conn.append(request)
self.connection.append(request) def run(self):
# 事件 循环
while True:
rlist, wlist, elist = select.select(self.conn, self.connection, self.conn, 0.05)
for w in wlist:
print(w.host,'链接成功')
# 表示 socket 和服务端链接 成功
txt = "GET / HTTP/1.0\r\nHost:%s\r\n\r\n"%(w.host)
w.socket.send(bytes(txt, encoding='utf8'))
self.connection.remove(w)
print('write over')
for r in rlist:
print(r.host, '有数据返回 ')
# r = HttpRequest object
recv_data = bytes()
while True:
try:
chunck = r.socket.recv(Buffer_size)
recv_data += chunck
except Exception as e:
break response = HttpResponse(recv_data) r.callback(response)
print('host=%s,返回数据为: recv_data=%s'%(r.host,recv_data))
self.conn.remove(r) if not self.conn:
break self.connection
self.conndef f1(response):
print('保存到文件,', response.header_dict)
def f2(response):
print('保存到数据库,', response.header_dict)
url_list = [
# 'cn.bing.com',
{"host": 'www.baidu.com', 'callback': f1},
{'host': 'www.cnblogs.com', 'callback': f2},
]req = AsyncRequest()
for item in url_list:
req.add_request(item['host'], item['callback'])req.run()# 等待 服务端的 链接成功 信号