基于Boost::Thread库的多线程网络爬虫程序

最新推荐文章于 2023-10-20 08:16:42 发布
最新推荐文章于 2023-10-20 08:16:42 发布
阅读量1.6k 收藏 1
点赞数 1
分类专栏： 开源项目（库） 文章标签： 网络爬虫 boost thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmyer/article/details/19482023
版权

在之前的几篇博文中，曾经设计实现了单线程爬虫和多线程爬虫，但是自己私下想了想，其实在实现多线程爬虫时，所有的线程都是自己通过调用底层的API来实现的，这样的调用一般来说并不是很好，并且又鉴于自己最近学习了下boost::thread相关的东西，于是索性想将之前的那个多线程爬虫程序改为boost::thread版的多线程爬虫，好了，废话说了这么多，现在该是设计代码的时候，代码如下：

#ifndef __HTTP_CURL__H
#define __HTTP_CURL__H
#include <boost/smart_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <curl/curl.h>
#include <string>
#include <set>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
using namespace std;
using namespace boost;

#define MAX_BUFFERSIZE 1024*10
#define MAX_THREAD 10
static int fileIndex = 1;

boost::mutex mut;
std::set<string> urlSet;
std::set<string> finishUrlSet;
typedef set<string>::iterator urlSet_Iter;

#define BEGIN_SPIDER(path) {urlSet.insert(path);}
class HttpCurl
{
    public:
        HttpCurl()
        {
            conn = NULL;
        }
        ~HttpCurl()
        {
            curl_easy_cleanup(conn);
        }
        static bool HttpCurlInit()
        {
            urlSet.clear();
            finishUrlSet.clear();
            CURLcode code;
            code = curl_global_init(CURL_GLOBAL_DEFAULT);
            if(CURLE_OK != code)
            {
                printf("Failed to global init default\n");
                return false;
            }
            return true;
        }

        bool InitCurlObject(string& context)
        {
            CURLcode code;
            conn = curl_easy_init();
            if(NULL == conn)
            {
                printf("Failed to create CURL\n");
                return false;
            }
            if(!setWriteFunc())
            {
                printf("Failed to set write\n");
                return false;
            }
            if(!setWriteBuff(context))
            {
                printf("Failed to set buffer\n");
                return false;
            }
            return true;
        }

        bool setWriteFunc()
        {
            CURLcode code;
            code = curl_easy_setopt(conn,CURLOPT_WRITEFUNCTION,HttpCurl::write);
            if(CURLE_OK != code)
            {
                printf("Failed to set write\n");
                return false;
            }
            return true;
        }
        bool setWriteBuff(string& context)
        {
            CURLcode code;
            code = curl_easy_setopt(conn,CURLOPT_WRITEDATA,&context);
            if(CURLE_OK != code)
            {
                printf("Failed to set write data\n");
                return false;
            }
            return true;
        }

        bool setUrl(string& url)
        {
            CURLcode code;
            code = curl_easy_setopt(conn,CURLOPT_URL,url.c_str());
            if(CURLE_OK != code)
            {
                printf("Failed to set URL\n");
                return false;
            }
            return true;
        }

        bool getHttpResponse()
        {
            CURLcode code;
            assert(conn);
            code = curl_easy_perform(conn);
            if(CURLE_OK != code)
            {
                printf("Failed to get response\n");
                return false;
            }

            return true;
        }

        static long write(void* data,int size,int nmemb,string& context)
        {
            long sizes = size*nmemb;
            std::string temp((char*)data,sizes);
            context += temp;
            return sizes;
        }
        bool save(const string& context,string filename)
        {
            CURLcode code;
            int retcode = 0;
            code = curl_easy_getinfo(conn,CURLINFO_RESPONSE_CODE,&retcode);
            if((CURLE_OK == code)&& retcode ==200)
            {
                int length = strlen(context.c_str());
                FILE* file = fopen(filename.c_str(),"w+");
                fseek(file,0,SEEK_SET);
                fwrite(context.c_str(),1,length,file);
                fclose(file);
                return  true;
            }
            return false;
        }
    private:
        CURL* conn;
};

class Spider
{
    public:
        Spider(shared_ptr<HttpCurl>& cul):httpCurl(cul)
        {
            httpCurlUrlSet.clear();
            context.clear();
            initCurl(httpCurl,context);
        }
        ~Spider(){}

        bool initCurl(shared_ptr<HttpCurl>& httpCurl,string& context)
        {
            return httpCurl->InitCurlObject(context);
        }
        void parseUrl(const string& context)
        {
            const string tag = "href";
            const string tag2 = "\"";
            const string tag3 = "http";
            string::size_type tempBegin,tempEnd,iter,httpIter;
            tempBegin = tempEnd = 0;
            iter= context.find(tag);
            while(iter != string::npos)
            {
                tempBegin = context.find(tag2,iter);
                if(tempBegin != string::npos)
                {
                    ++tempBegin;
                    tempEnd = context.find(tag2,tempBegin);
                }
                if(tempEnd != string::npos && tempEnd > tempBegin)
                {
                    string url;
                    url.assign(context,tempBegin,(tempEnd-tempBegin));
                    httpIter = url.find(tag3);
                    if(httpIter != string::npos)
                        httpCurlUrlSet.insert(url);
                }
                iter = context.find(tag,tempEnd);
            }
            printf("httpCurlUrlSet.size():%d\n",httpCurlUrlSet.size());
        }

        bool write(const string& context,const string& filename)
        {
            return httpCurl->save(context,filename);
        }

        void start(string url,string& context)
        {
            char filename[64];
            memset(filename,0,sizeof(filename));
            sprintf(filename,"%d.html",fileIndex++);

            httpCurl->setUrl(url);
            if(httpCurl->getHttpResponse())
            {
               parseUrl(context);
               write(context,filename);
               insertUrl();
            }
        }
        void insertUrl()
        {
            boost::unique_lock<boost::mutex> lock(mut);
            for( urlSet_Iter iter = httpCurlUrlSet.begin();iter != httpCurlUrlSet.end();++iter)
                urlSet.insert(*iter);
            httpCurlUrlSet.clear();
        }

        void displayUrl()
        {
            urlSet_Iter iter = urlSet.begin();
            for(; iter != urlSet.end();++iter)
            {
                cout<<*iter<<endl;
            }
        }

        string& getContext()
        {
            return context;
        }

        string getUrl()
        {
            urlSet_Iter iter;
            string url;
            boost::unique_lock<boost::mutex> lock(mut);
            for(iter = urlSet.begin();iter != urlSet.end();++iter)
            {
                if(finishUrlSet.find(*iter) != finishUrlSet.end())
                    continue;
                break;
            }
            if(iter != urlSet.end())
            {
                url = *iter;
                urlSet.erase(iter);
                finishUrlSet.insert(url);
                return url;
            }
            return "";
        }

    private:
        shared_ptr<HttpCurl> httpCurl;
        std::set<std::string> httpCurlUrlSet;
        std::string context;

};
static void task(Spider* spider)
{
    assert(spider);
    for(;;)
    {
        string url = spider->getUrl();
        if(url != "")
        {
            printf("url=%s\n",url.c_str());
            spider->start(url,spider->getContext());
        }
    }
}

#endif

测试程序：

#include "curlTest.h"

int main()
{
    HttpCurl::HttpCurlInit();
    BEGIN_SPIDER("www.baidu.com");

    shared_ptr<HttpCurl> curl1(new HttpCurl());
    Spider spider1(curl1);
    boost::thread thr1(boost::bind(&task,&spider1));

    shared_ptr<HttpCurl> curl2(new HttpCurl());
    Spider spider2(curl2);
    boost::thread thr2(boost::bind(&task,&spider2));

    thr1.join();
    thr2.join();
    //sleep(100);
    return 0;
}

测试结果：

url=http://anquan.baidu.com/bbs/thread-10353-1-1.html
httpCurlUrlSet.size():221
url=http://anquan.baidu.com/bbs/thread-10356-1-1.html
httpCurlUrlSet.size():365
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82280&amp;ptid=10353
httpCurlUrlSet.size():223
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82424&amp;ptid=10356
httpCurlUrlSet.size():365
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82455&amp;ptid=10353
httpCurlUrlSet.size():223
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82507&amp;ptid=10353
httpCurlUrlSet.size():365
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82703&amp;ptid=10353
httpCurlUrlSet.size():223
url=http://anquan.baidu.com/bbs/thread-10360-1-1.html
httpCurlUrlSet.size():365
url=http://anquan.baidu.com/bbs/thread-10365-1-1.html
httpCurlUrlSet.size():224
url=http://anquan.baidu.com/bbs/thread-10454-1-1.html
httpCurlUrlSet.size():366
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82343&amp;ptid=10365
httpCurlUrlSet.size():229
httpCurlUrlSet.size():366
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82848&amp;ptid=10454
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82964&amp;ptid=10454
httpCurlUrlSet.size():229
httpCurlUrlSet.size():366
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=82969&amp;ptid=10454
url=http://anquan.baidu.com/bbs/forum.php?mod=redirect&amp;goto=findpost&amp;pid=83171&amp;ptid=10454

总结

      本篇博文主要是针对上几篇博文的修改，主要是将相关的线程部分改为了boost::thread库，为了保持程序的完整性，将所有的程序贴了出来，方便阅读，设计思想很简单，主要是为boost::thread线程提供相应的处理函数即可，在实现的过程中，开始是想使用重载operator()的形式，但是测试下来发现其爬取不到任何的东西，个人感觉可能是在注册爬取网页缓存区出了问题，遂将其实现为函数的形式，然后再显式将其注册给线程，发现可行，总之，找到能够解决的方案就行，不要太追究其中的部分细节，尤其是在时间很紧的情况下，好了，等有时间再看看这个问题，本博文到此结束，多谢

如果需要，请注明转载，多谢

zmyer
关注
专栏目录
简易C++爬虫框架，基于多线程、多任务，快速实现网络数据爬取
02-27
在IT领域，C++是一种广泛使用的编程语言，...总之，这个简易的C++爬虫框架提供了一个学习和实践多线程爬虫的好机会，通过深入理解和修改源代码，你可以掌握网络爬虫开发的关键技能，为未来更复杂的项目打下坚实的基础。
Boost::thread库的使用
某花
10-27 1432
Boost::thread库的使用 2009/11/26 Kagula  http://blog.csdn.net/lee353086/article/details/4673790   阅读对象 本文假设读者有几下Skills [1]在C++中至少使用过一种多线程开发库，有Mutex和Lock的概念。 [2]熟悉C++开发，在开发工具中，能够编译、设置boost::thread库
boost::thread的六种使用方法总结
jinking01的专栏
09-18 1019
近期在使用sqlite3作为缓存和文件数据库，用于存储micros的落盘数据和实时缓存。其中在作为落盘数据库的时候，为了增加插入效率，我们采用批量插入，但是批量数据来源不是直接来自实时缓存，我们设计了2级缓存RingBuffer，当Ringbuffer中的数据快满的时候，我们才批量写向文件数据库，为此需要开启一个线程监听RingBuffer，实现读写并行。 原来没有使用过boost的thread...
如何使用爬虫(C++篇)
LanceZeng666的博客
01-04 3713
我们可以使用 std::string 的 find 函数来搜索特定字符串，并使用 std::string 的 substr 函数来提取子串。2.你可以使用 c++11 中的 std::thread 库来创建多个线程，并使用 std::mutex 库来保护共享资源。首先，你需要下载并安装 MySQL 数据库，并使用 MySQL 的命令行工具或图形化界面工具来创建一个数据库和表。另外，你还可以使用网页解析库，例如 HTML Agility Pack，来更方便地解析 HTML 网页。
Boost.Beast和C++编写程序
最新发布
weixin_73725158的博客
10-20 431
您可以根据需要修改代码，以下载音频文件或进行其他操作。请注意，由于这个示例使用了第三方API，您需要确保在实际应用中遵守API的使用条款。// 在这里，我们使用了第三方API（https://www.duoip.cn/get_proxy）来获取音频URL。以下是一个使用Boost.Beast和C++编写的爬虫程序，用于爬取。// 在这里，您可以使用audio_url来下载音频文件，或者进行其他操作。// 使用Boost.Beast的HTTP客户端来请求API。// 返回解析后的音频URL。
网络爬虫——c++版
ranyongqing的专栏
05-22 2373
程序整体思路： 给出种子文件，解析种子文件，然后得出相应网址，加入队列，采样广度优先，在之前出现过问题，经过一一修复之后，没有问题，经过我一天的测试，验证。使用内存大约几兆左右。#include #include #include #include #include #include #include #pragma comment(lib,"ws2_32.lib") using
spider:使用C和C++语言开发的网络爬虫系统
05-24
- **多线程/异步处理**：为了提高爬取速度，项目可能使用了C++的多线程（如`std::thread`）或异步I/O（如`boost.asio`）。 - **异常处理**：良好的错误处理机制可以确保爬虫在遇到问题时能够恢复或优雅地终止。 - ...
网络爬虫系统（C++)
06-14
总结来说，这个C++实现的网络爬虫系统综合运用了文件操作、网络编程、多线程技术以及数据处理等关键技能，展示了C++在构建复杂系统时的强大能力。学习和理解这个系统，不仅可以提升对C++编程的理解，也能深入掌握...
网络爬虫源码C++
11-30
C++11引入了std::thread库，使得在C++中使用多线程变得相对简单。同时，可以结合异步I/O模型，如Boost.ASIO库，来实现非阻塞的网络操作。 4. **文件操作**：爬取的数据通常需要存储到本地，这就涉及到了文件操作。...
VC++实现的网络爬虫程序，非常适合做二次开发
05-30
VC++支持多线程编程，可以使用`<thread>`库或Windows API如CreateThread。 5. **URL管理**：为了避免重复爬取同一个URL以及保持爬取顺序，需要一个URL管理器。它可以是一个队列或栈，用于存储待爬取的URL，并检查新...
boost中文手册C++
05-21
boost中文手册C++ boost库让我们更快、更好地使用C++进行大型系统或者服务器开发工作，提高工作效率，很值得一看！
过滤型爬虫的研究与设计
04-19
本文简要介绍了用于网页内容过滤的爬虫的基本原理，同时说明了如何使用HTMLPARSER实现过滤。
C++版网络爬虫
tianzhiyi1989sq的博客
08-07 1984
C++版网络爬虫 网络爬虫是按照一定规则，自动地抓取万维网信息的程序或脚本。这里用C++语言写一个小程序，实现简单的图片爬取的功能，目的是为了通过这么一个小程序理解爬虫的基本原理及基本流程。其大致实现流程如下： 图一：实现流程图 下面按照流程中的步骤依次用代码实现。 第一步：输入初始的URL 这里要实现的是图片资源的爬取，初始url可以选择一张带图片的网络地址，如http://www.tuxi.c...
C++ Post/Get请求（Boost.Asio库）
热门推荐
学习是一种信仰。
03-21 1万+
C++实现HTTP的Post/Get请求。代码跨平台。
libboost一些常用库（数据结构，迭代器，算法及字符串）
世事难料，保持低调
07-16 1万+
C++强大的重要原因之一就是它的库。而boost就是这样一个包罗万象的C++库，同时它也是C++标准库的官方后备军。不仅实用，功能全，而且灵活，高效，质量高。无论是学习或项目，都是有力的工具。下面罗列了容器、算法等几个重要类别下的主要子库。其中的一些已经是目前比较主流的C++11标准，有些在进入标准库的过程中，未来可能成为标准库的一部分。有些虽然进了标准库，但boost中的实现提供了额外的特性。总之，在boost中可以看到C++标准发展的一些趋势。
boost::split的使用
背着行囊去远方的博客
12-12 1万+
boost::split：可根据字符或者字符串来切割字符串 头文件： #include &lt;boost/algorithm/string.hpp&gt; 实例： ①根据一个字符进行切割 #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;boost/algorithm/string.hpp&gt; u...
CURL 多线程问题
weixin_34365417的博客
07-28 229
http://blog.csdn.net/wslz2001/article/details/12117127 默认情况下libcurl完成一个任务以后，出于重用连接的考虑不会马上关闭 如果没有新的TCP请求来重用这个连接，那么只能等到CLOSE_WAIT超时，这个时间默认在7200秒甚至更高，太多的CLOSE_WAIT连接会导致性能问题 解决方法： curl_easy_seto...
开源项目（库）之libcurl学习（一）
zmyer的专栏
02-13 3072
最近抽了点时间，将之前开发中使用到的一些开源库进行了下总结，主要是为了回顾一下自己所使用的一些库基础知识，并且加深理解，在这些库中，首先一个库就是libcurl，这个库很强大，当时在做openstack swift API时使用到了，这个库一个轻量级的HTTP编程库，里面封装了一套基于HTTP的上层应用协议的数据包的基本操作，其支持FTP，FTPS，TFTP，HTTP，HTTPS，GOPHER，T
Boost.Thread：C++中的多线程库
`boost::thread_specific_ptr`是Boost.Thread库提供的线程局部存储工具，它为每个线程维护单独的数据副本，避免了线程间的数据冲突。 ### 1.5 感谢与翻译术语表 文档中提到了对原作者Anthony Williams的贡献，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值