[Python]多线程网址爬虫：控制线程数，爬虫深度

python多线程作用于可以并行处理的函数上，一般是执行重复操作的一些函数。

在网站URL爬虫中，多线程爬虫作用的函数我设置的是getLink()这个函数：实现功能——根据url获取网页内容再从中爬取出url。

deadUrl = [] #存放死链
crawledUrl = [] #存放全部爬取过的url，避免重复爬取
#多线程爬取类，获得多线程函数参数
#入口参数：url,depth,thread. depth = 0则无需进行爬虫
#返回：爬取的url列表
class CrawlThread(threading.Thread):
    def __init__(self,url):
        threading.Thread.__init__(self)
        self.url = url
        self.linklist = ''
    # 目标url存活性判断:
    # 存活返回 True;否则返回False
    def urlStatus(self,url):
        try:
            status = urllib.urlopen(url).code
            if status == 200:
                return True
            else:
                deadUrl.append(url)
                return False
        except:
            return False
    #判断url域名是否为当前域名
    def judgeDomain(self,testLink):
        domain = urlparse.urlparse(self.url).netloc #当前域名
        if domain == urlparse.urlparse(testLink).netloc:
            return True
        else:
            return False
    # 读取整个网页
    def getHtml(self,url):
        try:
            page = urllib.urlopen(url)
            htmlbody = page.read()
            return htmlbody
        except:
            return None

    # 爬取url页面下的全部链接，多线程作用的函数
    def getLink(self,url):
        tmpLinks = []
        html = self.getHtml(url)
        soup = BeautifulSoup.BeautifulSoup(html)
        links = soup.findAll('a')  # 返回一个列表
        ###获取<a>中href的值
        bad_links = {None, '', '#', ' '}  # 无用链接列表
        bad_protocol = {'javascript', 'mailto', 'tel', 'telnet'}  # 无用的头部协议，如javascript等
        right_protocol = {'http', 'https'}  # 存放正确的协议头部
        linklist = []  # 存放正常的链接
        for link in links:
            if link.get('href') in bad_links or link.get('href').split(':')[0] in bad_protocol:  #去除无用链接
                continue
            else:  # 列表中包含相对地址
                linklist.append(link.get('href'))
        # 将相对地址转换为绝对地址
        linklist_tmp = []
        for link in linklist:
            if link.split(':')[0] in right_protocol:
                if self.judgeDomain(link): #域名相同
                    linklist_tmp.append(link)
            else:
                link_temp = urlparse.urljoin(self.url, link) #相对变绝对
                linklist_tmp.append(link_temp)
        linklist = linklist_tmp
        # 去除重复链接 set()函数
        linklist = list(set(linklist))
        if linklist:
            for link in linklist:
                if self.urlStatus(link) and link not in crawledUrl: #url存活性判断，去除死链
                    tmpLinks.append(link)
                    crawledUrl.append(link)
            for i in tmpLinks:
                print i
            return tmpLinks
        else:#不再存在未爬取链接
            return None
    def run(self): #线程创建后会直接运行run函数
        self.linklist = self.getLink(self.url)

    def getDatas(self):
        return self.linklist

这里多线程采用的是函数类的方式，即CrawlThread继承threading.Thread这个类，并重写它的run()方法，将需要多线程执行的代码放到run()方法下，即可。

控制线程数：即最大并行执行m个线程，等这m个并行线程结束后，再发起m个并行线程。

控制爬虫深度：采用的广度优先爬虫策略，加一个循环判断爬虫深度即可。

代码如下：

#广度遍历，爬取指定深度全部url
def crawlDepth(url,depth,maxThread):
    threadpool = [] #线程池
    if depth == 0:
        return url
    else:
        nowDepth = 1
        print '爬虫深度：', nowDepth
        th = CrawlThread(url)#获得深度为1时的全部url
        th.setDaemon(True)
        th.start()
        th.join()
        testLinks = Queue.deque(th.getDatas())
        print 'testLinks:',testLinks
        while nowDepth < depth and testLinks:
            nowDepth = nowDepth + 1
            print '爬虫深度：', nowDepth
            tmpLinks = []
            while testLinks:
                while len(threadpool) < maxThread:
                    if testLinks:
                        t = CrawlThread(testLinks.pop())
                        t.setDaemon(True)
                        threadpool.append(t)
                        t.start()
                    else:
                        break
                for thread in threadpool:#等待线程结束
                    thread.join()
                    #取出线程数据
                    tmp = thread.getDatas()
                    if tmp:
                        tmpLinks.extend(tmp)
                threadpool = []
            if tmpLinks:
                testLinks = list(set(tmpLinks))
            else:
                testLinks = Queue.deque([])
        return crawledUrl