高性能爬虫之单线程、多进程、多线程的使用，线程池、进程池、协程池的使用

最新推荐文章于 2024-04-03 09:34:05 发布
最新推荐文章于 2024-04-03 09:34:05 发布
阅读量1.3k 收藏 3
点赞数 2
分类专栏： 爬虫 文章标签： 爬虫 python 多线程 多进程 协程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69082030/article/details/129153374
版权

目录

注意：以下代码去掉了关键信息和url只展示怎么操作，具体实现可采用这个框架自己修改

一、单线程爬虫

思路分析：

  • 确定url地址
  • 确定数据的位置

代码实现

import requests
from lxml import etree


class Spider():

    def __init__(self):
        url = "http://www.baidu.com/page/{}"	# 注意这里是假url，实际跑不通
        # 构建构建每页url地址
        self.url_list = [ url.format(i) for i in range(1,14)]
        self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"}
    def get_html(self,html_url):
        # 向标题页发送请求，获取响应内容
        html_url_resp = requests.get(html_url, headers=self.headers)
        return html_url_resp.content

    def get_items(self,html_url_resp):
        # 获取每页的标题和标题url
        # 获取可以xpath的对象
        html_url_element = etree.HTML(html_url_resp)
        # 进行xpath提取标题和url
        html_url_a = html_url_element.xpath('//a[@class="recmd-content"]')
        # print(len(html_url_a))
        for a in html_url_a:
            item = {}
            # print(type(a))
            # 通过xpath得到的是列表，[0]是为了将列表中的内容取出来
            if a.xpath('./text()') != []:  #为空说明是广告
                item['title'] = a.xpath('./text()')[0]
                item['title_url'] = a.xpath('./@href')[0]
                self.save(item)

    def save(self,item):
        print(item)

    def run(self):
        for html_url in self.url_list:
            # 获取该页的标题详情
            html_url_resp = self.get_html(html_url)
            # 获取每页标题和标题url
            self.get_items(html_url_resp)



if __name__ == '__main__':
    start_time = datetime.datetime.now()
    spider = Sprider()
    spider.run()
    end_time = datetime.datetime.now()
    print('单线程消耗时间{}'.format(end_time-start_time))
    # 单线程消耗时间0:00:06.377732

二、 多线程爬虫

在前面爬虫基础知识案例中我们发现请求回来的总数据不是太多,时间性对来说还是比较快的,那么如果该网站有大量数据等待爬虫爬取,我们是不是需要使用多线程并发来操作爬虫的网络请求呢?

1、多线程的方法使用

在python3中，主线程主进程结束，子线程，子进程不会结束

为了能够让主线程回收子线程，可以把子线程设置为守护线程，即该线程不重要，主线程结束，子线程结束(爬虫不能搞守护线程我觉得，不然还没执行的子线程都不爬了)

t1 = threading.Thread(targe=func,args=(,))
t1.setDaemon(True) # 设置为守护线程
t1.start() #此时线程才会启动

2、队列模块的使用

from queue import Queue
q = Queue(maxsize=100) # maxsize为队列长度
item = {}
q.put_nowait(item) #不等待直接放，队列满的时候会报错
q.put(item) #放入数据，队列满的时候会阻塞等待
q.get_nowait() #不等待直接取，队列空的时候会报错
q.get() #取出数据，队列为空的时候会阻塞等待
q.qsize() #获取队列中现存数据的个数 
q.join() # 队列中维持了一个计数(初始为0)，计数不为0时候让主线程阻塞等待，队列计数为0的时候才会继续往后执行
         # q.join()实际作用就是阻塞主线程，与task_done()配合使用
         # put()操作会让计数+1，task_done()会让计数-1
         # 计数为0，才停止阻塞，让主线程继续执行
q.task_done() # put的时候计数+1，get不会-1，get需要和task_done 一起使用才会-1

3、多线程实现思路剖析

把爬虫中的每个步骤封装成函数，分别用线程去执行不同的函数通过队列相互通信，函数间解耦

在这里插入图片描述

4、代码实现

import requests
from lxml import etree
import datetime
from queue import Queue
from threading import Thread

class Spider():

    def __init__(self):
        self.base_url = "http://www.baidu.com/8hr/page/{}"	# 注意这是假url，实际跑不通得换你自己的
        # 构建构建每页url地址
        self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"}
        # 创建队列
        self.q_url = Queue(10)
        self.q_html = Queue(10)
        self.q_item = Queue(10)


    # 生产url
    def get_url(self):
        for i in range(1, 14):
            url = self.base_url.format(i)
            self.q_url.put(url)

    # 获取对应url的response内容
    def get_html(self):
        while True:
            # 向标题页发送请求，获取响应内容
            url = self.q_url.get()
            html_url_resp = requests.get(url, headers=self.headers)
            self.q_html.put(html_url_resp.content)
            self.q_url.task_done() # 计数 -1
    # 获取每页的标题和url
    def get_items(self):
        while True:
            # 获取每页的响应内容
            html_url_resp = self.q_html.get()
            # 获取可以xpath的对象
            html_url_element = etree.HTML(html_url_resp)
            # 进行xpath提取标题和url
            html_url_a = html_url_element.xpath('//a[@class="recmd-content"]')
            # print(len(html_url_a))
            titles = []
            for a in html_url_a:
                # print(type(a))
                # 通过xpath得到的是列表，[0]是为了将列表中的内容取出来
                if a.xpath('./text()') != []:  #为空说明是广告
                    item = {}
                    item['title'] = a.xpath('./text()')[0]
                    item['title_url'] = a.xpath('./@href')[0]
                    titles.append(item)

            self.q_item.put(titles)
            self.q_html.task_done()

    def save(self):
        while True:
            items = self.q_item.get()
            for item in items:
                print(item)
            self.q_item.task_done()


    def run(self):
        thread_list =[]
        t_url = Thread(target=self.get_url)
        thread_list.append(t_url)

        for i in range(3):
            t_html = Thread(target=self.get_html)
            thread_list.append(t_html)

        for i in range(3):
            t_items = Thread(target=self.get_items)
            thread_list.append(t_items)

        t_save = Thread(target=self.save)
        thread_list.append(t_save)

        for t in thread_list:
            # t.setDaemon(True) # 设置为守护线程
            t.start() #此时线程才会启动

        for q in [self.q_url, self.q_html, self.q_item]:
            q.join()  # 主线程阻塞，直到每个q队列计数为0
            print('程序结束了')


if __name__ == '__main__':
    start_time = datetime.datetime.now()
    spider = Spider()
    spider.run()
    end_time = datetime.datetime.now()
    print('多线程消耗时间{}'.format(end_time-start_time))
	
	# 单线程消耗时间0:00:06.377732
    # 多线程消耗时间0:00:02.270735

注意点：

  • put会让队列的计数+1，但是单纯的使用get不会让其-1，需要和task_done同时使用才能够-1。
  • task_done不能放在另一个队列的put之前，否则可能会出现数据没有处理完成，程序结束的情况。

三、多进程爬虫

使用和多线程差不多，不同库而已

在一个进程中无论开多少个线程都只能运行在一个CPU的核心之上，这是python的特点，不能说是缺点！

如果我们想利用计算机的多核心优势，就可以用多进程的方式实现，思路和多线程相似，只是对应的api不相同。

1、多进程程的方法使用

from multiprocessing import Process  #导入模块
t1 = Process(targe=func,args=(,)) #使用一个进程来执行一个函数
t1.daemon = True  #设置为守护进程
t1.start() #此时线程才会启动

2、多进程中队列的使用

多进程中使用普通的队列模块会发生阻塞，对应的需要使multiprocessing提供的JoinableQueue模块，其使用过程和在线程中使用的queue方法相同

3 代码实现

import requests
from lxml import etree
import datetime
from multiprocessing import Process
from multiprocessing import JoinableQueue as Queue

class Sprider():

    def __init__(self):
        self.base_url = "http://www.baidu.com/8hr/page/{}"	# 注意这是假url，实际跑不通,得换你自己的
        # 构建构建每页url地址
        self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"}
        # 创建队列
        self.q_url = Queue(10)
        self.q_html = Queue(10)
        self.q_item = Queue(10)


    # 生产url
    def get_url(self):
        for i in range(1, 14):
            url = self.base_url.format(i)
            self.q_url.put(url)

    # 获取对应url的response内容
    def get_html(self):
        while True:
            # 向标题页发送请求，获取响应内容
            url = self.q_url.get()
            html_url_resp = requests.get(url, headers=self.headers)
            self.q_html.put(html_url_resp.content)
            self.q_url.task_done()
    # 获取每页的标题和url
    def get_items(self):
        while True:
            # 获取每页的响应内容
            html_url_resp = self.q_html.get()
            # 获取可以xpath的对象
            html_url_element = etree.HTML(html_url_resp)
            # 进行xpath提取标题和url
            html_url_a = html_url_element.xpath('//a[@class="recmd-content"]')
            # print(len(html_url_a))
            titles = []
            for a in html_url_a:
                # print(type(a))
                # 通过xpath得到的是列表，[0]是为了将列表中的内容取出来
                if a.xpath('./text()') != []:  #为空说明是广告
                    item = {}
                    item['title'] = a.xpath('./text()')[0]
                    item['title_url'] = a.xpath('./@href')[0]
                    titles.append(item)

            self.q_item.put(titles)
            self.q_html.task_done()

    def save(self):
        while True:
            items = self.q_item.get()
            for item in items:
                print(item)
            self.q_item.task_done()


    def run(self):
        process_list =[]
        p_url = Process(target=self.get_url)
        process_list.append(p_url)

        for i in range(2):
            p_html = Process(target=self.get_html)
            process_list.append(p_html)

        for i in range(2):
            p_items = Process(target=self.get_items)
            process_list.append(p_items)

        p_save = Process(target=self.save)
        process_list.append(p_save)

        for t in process_list:
            # t.setDaemon(True) # 设置为守护线程
            t.start() #此时线程才会启动

        for q in [self.q_url, self.q_html, self.q_item]:
            q.join()  # 主线程阻塞，直到每个q队列计数为0
            print('程序结束了')


if __name__ == '__main__':
    start_time = datetime.datetime.now()
    spider = Sprider()
    spider.run()
    end_time = datetime.datetime.now()
    print('多进程消耗时间{}'.format(end_time-start_time))
    
	# 单线程消耗时间0:00:06.377732
    # 多线程消耗时间0:00:02.270735
	# 多进程消耗时间0: 00:03.296609

上述多进程实现的代码中，multiprocessing提供的JoinableQueue可以创建可连接的共享进程队列。和普通的Queue对象一样，队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。 对应的该队列能够和普通队列一样能够调用task_done和join方法。

小结

  • multiprocessing导包:from multiprocessing import Process
  • 创建进程: Process(target=self.get_url_list)
  • 添加入队列: put
  • 从队列获取:get
  • 守护线程:t.daemon=True
  • 主线程阻塞: q.join()
  • 跨进程通讯可以使用from multiprocessing import JoinableQueue as Queue

四、线程池实现爬虫

1、线程池使用方法介绍

  • 实例化线程池对象
 from multiprocessing.dummy import Pool
 pool = Pool(processes=3) # 默认大小是cpu的个数
 """源码内容：
 if processes is None:
     processes = os.cpu_count() or 1 
     # 此处or的用法：
         默认选择or前边的值，
         如果or前边的值为False，就选择后边的值
 """
  • 把从发送请求，提取数据，到保存合并成一个函数，交给线程池异步执行

使用方法pool.apply_async(func)

 def exetute_requests_item_save(self):
     url = self.queue.get()
     html_str = self.parse_url(url)
     content_list = self.get_content_list(html_str)
     self.save_content_list(content_list)
     self.total_response_num +=1

 pool.apply_async(self.exetute_requests_item_save)
  • 添加回调函数

通过apply_async的方法能够让函数异步执行，但是只能够执行一次，为了让其能够被反复执行，通过添加回调函数的方式能够让_callback 递归的调用自己，同时需要指定递归退出的条件。

 def _callback(self,temp):
     if self.is_running:
          pool.apply_async(self.exetute_requests_item_save,callback=self._callback)

pool.apply_async(self.exetute_requests_item_save,callback=self._callback)
  • 确定程序结束的条件 程序在获取的响应和url数量相同的时候可以结束
 while True: #防止主线程结束
     time.sleep(0.0001)  #避免cpu空转，浪费资源
     if self.total_response_num>=self.total_requests_num:
         self.is_running= False
         break
 self.pool.close() #关闭线程池，防止新的线程开启
# self.pool.join() #等待所有的子线程结束

2、使用线程池实现爬虫的具体实现

import requests
from lxml import etree
import datetime
from queue import Queue
from multiprocessing.dummy import Pool
import time


class Spider():

    def __init__(self):
        self.url = "http://www.baidu.com/8hr/page/{}"	# 注意这是假url，实际跑不通,得换你自己的
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36'
        }
        # 构建构建每页url地址
        # self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"}
        # 创建队列
        self.q_url = Queue()
        # 创建进程池对象
        self.pool = Pool(5)
        # 请求url总数据
        self.total_request_num = 0
        # 获取响应总数
        self.total_response_num = 0
        # 停止回调标志
        self.is_running = True


    # 获取url
    def get_url(self):
        for i in range(1, 14):
            url = self.url.format(i)
            # 将生成的url放入到队列中
            self.q_url.put(url)
            self.total_request_num += 1

    # 向标题页发送请求，获取响应内容
    def get_html(self,url):
        resp = requests.get(url, headers=self.headers)

        return resp.content

    # 获取每页的标题和标题url
    def get_items(self,html_resp):
        # 获取可以xpath的对象
        html_url_element = etree.HTML(html_resp)
        # 进行xpath提取标题和url
        html_url_a = html_url_element.xpath('//a[@class="recmd-content"]')
        # print(len(html_url_a))
        titles = []
        for a in html_url_a:
            item = {}
            # print(type(a))
            # 通过xpath得到的是列表，[0]是为了将列表中的内容取出来
            if a.xpath('./text()') != []:  #为空说明是广告
                item['title'] = a.xpath('./text()')[0]
                item['title_url'] = a.xpath('./@href')[0]
                titles.append(item)
        return titles

    # 保存
    def save(self,titles):
        for t in titles:
            print(t)

    # 完整的执行流程
    def execute_request_items_save(self):
        url = self.q_url.get()
        html_resp = self.get_html(url)
        titles = self.get_items(html_resp)
        self.save(titles)
        self.total_response_num += 1
        return '完整执行'

    # 回调函数
    def _callback(self,xxx):# callback函数必须接收一个参数！
        # xxx参数是self.execute_request_item_save的返回值！！！
        # 哪怕用不上 也必须接收！
        print(xxx)
        if self.is_running:
            self.pool.apply_async(self.execute_request_items_save, callback=self._callback)


    def run(self):
        self.get_url()

        for i in range(5):
            self.pool.apply_async(self.execute_request_items_save, callback=self._callback)
        # 退出机制
        while True:
            #避免cpu空转，浪费资源
            time.sleep(0.0001)
            if self.total_response_num == self.total_request_num and self.total_request_num == 13:
                self.is_running = False
                break
        self.pool.close()

        print('程序执行结束')


if __name__ == '__main__':
    start_time = datetime.datetime.now()
    spider = Spider()
    spider.run()
    end_time = datetime.datetime.now()
    print('多线程池消耗时间{}'.format(end_time-start_time))


	# 单线程消耗时间0:00:06.377732
	# 多进程消耗时间0: 00:03.296609
    # 多线程池消耗时间0:00:01.761484

小结：

  • 线程池导包: from multiprocessing.dummy import Pool
  • 线程池的创建:pool = Pool(process=3)
  • 线程池异步方法:pool.apply_async(func)

五、协程池实现爬虫

1、协程池模块使用介绍

协程池模块

import gevent.monkey
 gevent.monkey.patch_all()
 from gevent.pool import Pool

2、使用协程池实现爬虫的具体实现过程

import gevent.monkey
# monkey补丁要打在发送请求之前
gevent.monkey.patch_all()
import requests
from lxml import etree
import datetime
from queue import Queue
from gevent.pool import Pool
import time


class Sprider():

    def __init__(self):
        self.url = "http://www.baidu.com/8hr/page/{}"		# 注意这是假url，实际跑不通,得换你自己的
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36'
        }
        # 构建构建每页url地址
        # self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36"}
        # 创建队列
        self.q_url = Queue()
        # 创建进程池对象
        self.pool = Pool(5)
        # 请求url总数据
        self.total_request_num = 0
        # 获取响应总数
        self.total_response_num = 0
        # 停止回调标志
        self.is_running = True


    # 获取url
    def get_url(self):
        for i in range(1, 14):
            url = self.url.format(i)
            # 将生成的url放入到队列中
            self.q_url.put(url)
            self.total_request_num += 1

    # 向标题页发送请求，获取响应内容
    def get_html(self,url):
        resp = requests.get(url, headers=self.headers)

        return resp.content

    # 获取每页的标题和标题url
    def get_items(self,html_resp):
        # 获取可以xpath的对象
        html_url_element = etree.HTML(html_resp)
        # 进行xpath提取标题和url
        html_url_a = html_url_element.xpath('//a[@class="recmd-content"]')
        # print(len(html_url_a))
        titles = []
        for a in html_url_a:
            item = {}
            # print(type(a))
            # 通过xpath得到的是列表，[0]是为了将列表中的内容取出来
            if a.xpath('./text()') != []:  #为空说明是广告
                item['title'] = a.xpath('./text()')[0]
                item['title_url'] = a.xpath('./@href')[0]
                titles.append(item)
        return titles

    # 保存
    def save(self,titles):
        for t in titles:
            print(t)

    # 完整的执行流程
    def execute_request_items_save(self):
        url = self.q_url.get()
        html_resp = self.get_html(url)
        titles = self.get_items(html_resp)
        self.save(titles)
        self.total_response_num += 1
        return '完整执行'

    # 回调函数
    def _callback(self,xxx):# callback函数必须接收一个参数！
        # xxx参数是self.execute_request_item_save的返回值！！！
        # 哪怕用不上 也必须接收！
        print(xxx)
        if self.is_running:
            self.pool.apply_async(self.execute_request_items_save, callback=self._callback)


    def run(self):
        self.get_url()

        for i in range(5):
            self.pool.apply_async(self.execute_request_items_save, callback=self._callback)
        # 退出机制
        while True:
            #避免cpu空转，浪费资源
            time.sleep(0.0001)
            if self.total_response_num == self.total_request_num and self.total_request_num == 13:
                self.is_running = False
                break
        # self.pool.close()   # 协程没有过close函数
        print('程序执行结束')


if __name__ == '__main__':
    start_time = datetime.datetime.now()
    spider = Sprider()
    spider.run()
    end_time = datetime.datetime.now()
    print('多协程池消耗时间{}'.format(end_time-start_time))

	# 单线程消耗时间0:00:06.377732
	# 多进程消耗时间0: 00:03.296609
    # 多线程池消耗时间0:00:01.761484
    # 多协程池消耗时间0:00:01.689546

总结

对单线程、多进程、多线程、线程池、进程池、协程池的使用进行了总结，但是感觉还是有些缺陷。参考我其他文章把

名难取aaa
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python库 | funboost-13.9-py3-none-any.whl
03-20
python库，解压后可用。 资源全名：funboost-13.9-py3-none-any.whl
媲美celery的分布式调度框架funboost
moriweiji的博客
04-25 2956
celery的分布式调度框架funboost，分布式爬虫，数据清洗，数据处理分析工作这的福音
FunBoost：提升你的Python性能，轻量级且高效
最新发布
gitblog_00049的博客
04-03 504
FunBoost：提升你的Python性能，轻量级且高效 项目地址:https://gitcode.com/ydf0509/funboost FunBoost 是一个针对Python开发者的优化工具库，旨在通过底层优化提高代码执行速度，而无需改变原有代码结构。对于那些希望在保持代码可读性和简洁性的同时，追求更佳性能的应用来说，这是一个非常有价值的项目。 技术分析 FunBoost主要采用了以下几种...
python-整理 多线程，多进程，线程池，进程池，协程，协程池
叽里呱啦的一大摊，人生太艰难.
07-19 409
python-多线程，多进程，线程池，进程池，协程，协程池。
Flask 入门
XWenXiang的博客
08-10 565
Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。.........
python爬虫之线程池和进程池
weixin_30410119的博客
01-31 179
一、需求 　　最近准备爬取某电商网站的数据，先不考虑代理、分布式，先说效率问题（当然你要是请求的太快就会被封掉，亲测，400个请求过去，服务器直接拒绝连接，心碎），步入正题。一般情况下小白的我们第一个想到的是for循环，这个可是单线程啊。那我们考虑for循环直接开他个5个线程，问题来了，如果有一个url请求还没有回来，后面的就干等，这么用多线程等于没用，到处贴创可贴。 二、性能考虑 　　确定...
python爬虫之线程池和进程池功能与用法详解
12-25
本文实例讲述了python爬虫之线程池和进程池功能与用法。分享给大家供大家参考，具体如下： 一、需求 最近准备爬取某电商网站的数据，先不考虑代理、分布式，先说效率问题（当然你要是请求的太快就会被封掉，亲测，...
详解python之多进程和进程池(Processing库)
12-25
一直想学习多进程或多线程,但之前只是单纯看一点基础知识还有简单的介绍,无法理解怎么去应用,直到前段时间看了github的一个爬虫项目涉及到多进程,多线程相关内容,一边看一边百度相关知识点,现在把一些相关知识点和...
Python爬取股票数据存入mysql，获取股票（最新、最高、今开、成交量、成交额、量比、换手率、涨幅）支持多线程+数据库连接池
07-08
运行说明 首先要保证本机已经安装MySQL和Redis. 爬虫部分 采用单线程Python爬虫 + MySQL....1、运行文件databaseInitialization.py初始化数据库和...多线程+数据库连接池爬虫`insertRecordsMultiThreadConnectionPool.
基于Linux的python多线程爬虫程序设计.zip
10-16
本主题“基于Linux的Python多线程爬虫程序设计”将深入探讨如何在Linux环境下利用Python实现多线程爬虫，以优化网络爬虫的性能。 首先，我们需要了解Python中的多线程。Python的`threading`模块提供了创建和管理...
百度知道多线程采集问题答案
01-10
在IT行业中，多线程采集是一项常见的数据抓取技术，特别是在大数据分析和网络爬虫领域。本主题聚焦于“百度知道”问答平台的多线程采集问题及其解决方案。百度知道作为一个海量信息的平台，提供了丰富的用户问答数据...
python爬虫之多线程、多进程爬虫
热门推荐
笑笑布丁的博客
05-09 4万+
一、原因 多线程对爬虫的效率提高是非凡的，当我们使用python的多线程有几点是需要我们知道的： 1.Python的多线程并不如java的多线程，其差异在于当python解释器开始执行任务时，受制于GIL(全局解释所)，Python 的线程被限制到同一时刻只允许一个程执行这样一个执行模型。 2.Python 的线程更适用于处理 I/O 和其他需要并发行的阻塞操作（比如等待 I/O、等待从数据库获取...
【Python】为什么要使用多线程爬虫
weixin_47383889的博客
11-06 845
多线程爬虫相较于单线程爬虫有比较明显的性能提升，具体表现在网络I/O的时候多线程爬虫的CPU资源会释放给其他线程使用，当这种I/O数量越高的时候这种效果就越明显
docker安装redis及使用
qq_44846224的博客
12-02 453
安装Redis 1.通过docker search redis和docker pull redis下载redis镜像# docker pull redis 2.创建 data 、conf、以及redis.conf配置文件，如若不然，无法通过redis deskTop manager访问# mkdir -p /root/redis/data //-p 表示递归创建 如果没有就创建 mkdir -p /root/redis/conf vim /root/redis/conf/redis.conf
Funboot——基于Yii2的Saas快速开发平台
花生——宁静致远
10-13 765
Funboot——基于Yii2的Saas快速开发平台 Funboot是一个一站式Saas快速开发平台，基于Yii 2.0框架，提供代码生成器，提供通用组件帮助开发者聚焦业务，并提供多域名、多商户支持。 问题反馈 在使用中有任何问题，欢迎在QQ群众反馈 QQ群：798843502 在线Demo Funboot开发平台 演示地址：https://www.funboot.net/backend/ test 123456 FunPay个人收款系统 演示地址：https://funpay.funboot.net/
boost高并发网络框架+线程池
herostarone的专栏
05-01 1万+
boost的官方例子，有单线程的网络框架，httpserver2是线程池的。下面参照网上某人的代码修改了一点（忘了哪位大仙的代码了）   测试工具，适用stressmark，测试效果非常好， 9000个/s       #include stdio.h> #include "AuthenHandle.h" #include "configure.h" #
boost库的常用组件的使用
斑竹的程序设计专栏
11-29 1503
1.boost::anyboost::any是一种通用的数据类型，可以将各种类型包装后统一放入容器内最重要的它是类型安全的。有点象COM里面的variant.使用方法：any::type() 返回包装的类型any_cast可用于any到其他类型的转化 #include boost/any.hpp>void test_any(){ typedef std::vectorboost::any> man
boost框架_介绍Boost解析器框架
cusi77914的博客
06-23 1783
对于C ++程序员来说，更复杂的任务之一是在合理的时间段内对解析器进行编码。 在为SQL或C ++等成熟的语言开发编译器时，使用GNU Flex / Bison或ANTLR解析器生成器通常很有意义。 但是对于使用更简单的Backus Naur Form（BNF）的语法而言，这些工具的陡峭学习曲线并不总是能够证明投资的合理性。 另一种选择是使用与标准Linux®发行版或Boost regex或t...
Django 名称空间、伪静态、视图层、FBV与CBV介绍
go|Python的个人博客
02-20 571
解决方法: 伪静态 视图层 三板斧 JsonResponse对象 form表单上传文件 FBV和CBV CBV源码剖析总结 注意: 不要轻易修改源码
使用python3 进行多线程爬虫 线程池
04-13
使用 Python3 进行多线程爬虫的话，可以使用线程池来管理和调度线程，减少线程创建和销毁的频率，提高效率和性能。常用的线程池库有：concurrent.futures 和 ThreadPoolExecutor。在爬取网站时，可以通过多线程的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值