zoukankan      html  css  js  c++  java
  • 爬虫性能相关

    一、背景知识

        爬虫的本质就是一个socket客户端与服务端的通信过程,如果我们有多个url待爬取,只用一个线程且采用串行的方式执行,那只能等待爬取一个结束后才能继续下一个,效率会非常低。

    需要强调的是:对于单线程下串行N个任务,并不完全等同于低效,如果这N个任务都是纯计算的任务,那么该线程对cpu的利用率仍然会很高,之所以单线程下串行多个爬虫任务低效,是因为爬虫任务是明显的IO密集型程序。

    关于IO模型详见链接:http://www.cnblogs.com/linhaifeng/articles/7454717.html

        那么该如何提高爬取性能呢?且看下述概念

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

    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.一个简单的解决方案:多线程或多进程

    #在服务器端使用多线程(或多进程)。多线程(或多进程)的目的是让每个连接都拥有独立的线程(或进程),这样任何一个连接的阻塞都不会影响其他的连接。
    
    import requests
    from threading import Thread,current_thread
    
    IO密集型用多线程,计算密集型用多进程
    
    def parse_page(res):
        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'
             ]
        for url in urls:
            t = Thread(target=get_page, args=(url,))
            t.start()

    结果如下:

    该方案存在的问题是:采取多进程或多线程的方式,都是无限制的开启多线程或者多进程,在遇到同时要响应成百上千个请求时,则无论是多进程还是多线程都会

    占据系统资源,降低系统对外界的响应效率,而且线程与进程本身也更容易进入假死状态。

    3.改进方案:线程池或进程池+异步调用,即提交一个任务后并不会等待任务结束,而是直接执行下一行代码

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

     进程池或线程池:异步调用+回调机制

    #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)))  #current_thread().getName() 获取当前线程名
    def get_page(url): print('%s 下载 %s' %(current_thread().getName(),url)) response=requests.get(url) if response.status_code == 200: #响应成功状态码为200时,返回 return response.text if __name__ == '__main__': urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://taobao.com'] pool=ThreadPoolExecutor(50) #开启50个线程或进程 # pool=ProcessPoolExecutor(50) for url in urls: pool.submit(get_page,url).add_done_callback(parse_page) #使用回调函数 pool.shutdown(wait=True)

     结果如下:

    改进后方案其实也存在问题

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

     对于上面例子中可能会出现成千上百个客户请求时,“”线程池“”和“进程池”或许可以缓解部分压力,但不能解决所有问题,总之,多线程模型可以方便高效的解决小规模的服务请求,但面对大规模的服务请求,多线程模型也会遇到瓶颈,可以用非阻塞接口来尝试解决这个问题。

     补充:gevent模块

    from gevent import joinall,spawn,monkey;monkey.patch_all()
    import requests
    from threading import current_thread
    
    def parse_page(res):
        print('%s PARSE %s' %(current_thread().getName(),len(res)))
    
    def get_page(url,callback=parse_page):
        print('%s GET %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',
            'https://www.taobao.com',
            'https://www.openstack.org',
        ]
    
        tasks=[]
        for url in urls:
            tasks.append(spawn(get_page,url))
    
        joinall(tasks)

    结果如下

    三、高性能

          上面无论哪一种解决方案都没有解决一个性能相关的问题:IO阻塞,无论是多线程还是多进程,在遇到IO时都会被操作系统强行夺走cpu的执行权限,

    程序的执行效率因此就降低了下来。

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

    1、在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后切换到其他任务执行(一旦遇到IO,用yield from)
        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()

         2、但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()
    
    asyncio+自定义http协议报头
    asyncio+自定义http协议报头
  • 相关阅读:
    poj2528Mayor's posters(线段树加离散化)第一次接触离散化 做的挺辛苦的
    poj1789Truck History(简单最小生成树)
    【洛谷P2468】粟粟的书架
    【洛谷P3523】DYNDynamite
    【SP1716】GSS3 Can you answer these queries III
    【洛谷P3320】寻宝游戏
    【洛谷P3322】排序
    【GMOJ6293】迷宫
    【GMOJ4051】序列统计
    【洛谷P4719】【模板】动态 DP
  • 原文地址:https://www.cnblogs.com/moning/p/8330569.html
Copyright © 2011-2022 走看看