# 总的糗事div
//div[contains(@class, "article block untagged")]
# 糗事作者信息：
.//h2
# 糗事内容：
.//div[@class="content"]/span
# 发表的图片信息：
.//div[@class="thumb"]//@src
# 点赞数：
.//span[@class="stats-vote"]/i
# 评论数：
.//a[@class="qiushi_comments"]/i

"""
多线程爬虫实战：糗事百科爬取
"""

# 导入所需要的对应模块
import threading
import json
import requests
from lxml import etree
from queue import Queue


# 全局变量
# 控制爬取以及解析线程结束条件
CRAWL_EXIT = False
PARSE_EXIT = False
# 所要爬取网站的基本url
URL = 'https://www.qiushibaike.com/8hr/page/'


class ThreadCrawl(threading.Thread):
    """
    网页爬取线程，负责对网页队列中的页面进行爬取
    """
    def __init__(self, thread_name, page_queue, html_queue):
        # 首先线程类得先调用父类的初始化方法
        # 这里调用父类的方法有两种方式：
        # 一种是：threading.Thread.__init(self)
        # 另一种是：super(ThreadCrawl, self).__init__()
        # 这两种方式的区别在只有一个父类的情况下是看不出来的
        # 但是假如有多个父类的情况下，第一种方式只是调用了第一个父类的方式
        # 而第二种方式便可以将所有的父类都进行调用
        # 还有一个区别是在于修改代码的时候，第一种方式修改起来比较麻烦
        # 而第二种便只用修改类中继承的父类名即可
        # 因此，推荐使用第二种方式来进行父类方法调用
        super(ThreadCrawl, self).__init__()

        # 创建对应的类属性
        self.thread_name = thread_name
        self.page_queue = page_queue
        self.html_queue = html_queue
        self.headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; AS; rv:11.0) like Gecko'}

    def run(self):
        """
        启动线程，开始进行网页的爬取
        :return:
        """
        while not CRAWL_EXIT:
            print(self.thread_name+'开始爬取网页')
            try:
                # 队列的get方法中有一个参数block，
                # 默认为true，表示队列为空时阻塞程序，等待有数据进队列时再进行get操作
                # 设置为false的话便不用使程序停下来，只是会抛出一个异常，因此需要进行异常捕获
                page = self.page_queue.get(False)

                # 构造请求url，并使用requests进行发送请求
                url = URL+str(page)+'/'
                # 注意requests使用的时候获取返回的内容是使用text属性而非方法
                html = requests.get(url, headers=self.headers).text

                # 将爬取下来的网页保存到队列中去
                self.html_queue.put(html)

            except Exception:
                pass
            print(self.thread_name+'网页爬取完成')


class ThreadParse(threading.Thread):
    """
    网页解析线程，负责对爬取下来的网页进行解析
    """
    def __init__(self, thread_name, html_queue, file, lock):
        super(ThreadParse, self).__init__()
        self.thread_name = thread_name
        self.html_queue = html_queue
        self.file = file
        self.lock = lock

    def run(self):
        """
        启动线程，开始进行网页解析
        :return:
        """
        while not PARSE_EXIT:
            print(self.thread_name+'开始进行解析')
            try:
                html = self.html_queue.get(False)
                self.parse(html)
            except Exception:
                pass
            print(self.thread_name+'解析结束')

    def parse(self, html):
        """
        处理html界面中的数据
        :param html:
        :return:
        """
        # 将返回的网页信息转换为html dom模式
        content = etree.HTML(html)

        # 获取匹配结果，即为返回的一个糗事列表
        qiushi_list = content.xpath('//div[contains(@class, "article block untagged")]')

        # 创建一个字典来保存爬取的数据
        content_list = {}
        # 对每一个糗事信息进行处理
        for text in qiushi_list:
            # 用户名,取出内容之后并将其首尾的换行符去除
            user_name = text.xpath('.//h2')[0].text.strip('\n')
            # print(user_name)

            # 糗事内容,text为取出标签里的内容,取出内容之后并将其首尾的换行符去除
            con = text.xpath('.//div[@class="content"]/span')[0].text.strip('\n')
            # print(con)

            # 图片链接,注意，有些帖子有图片，有些没有
            image_url = text.xpath('.//div[@class="thumb"]//@src')
            # print(image_url)

            # 点赞数
            zan_number = text.xpath('.//span[@class="stats-vote"]/i')[0].text
            # print(zan_number)

            # 评论数
            comment_number = text.xpath('.//a[@class="qiushi_comments"]/i')[0].text
            # print(comment_number)

            # 将每一条糗事中的数据保存到字典中去
            content_list = {
                'user_name': user_name,
                'con': con,
                'image_url': image_url,
                'zan_number': zan_number,
                'comment_number': comment_number
            }

            # with 后面有两个必须执行的操作：__enter__ 和 _exit__
            # 不管里面的操作结果如何，都会执行打开、关闭
            # 打开锁、处理内容、释放锁
            with self.lock:
                # 用追加的方式将字典中的内容保存到本地文件中
                self.file.write(json.dumps(content_list, ensure_ascii=False) + '\n')


def main():
    """
    主函数，负责主要功能流程实现
    :return:
    """
    # 页码队列,长度为10
    page_queue = Queue(10)
    # 将从1到10的数字保存到页码队列中去
    for i in range(1, 11):
        page_queue.put(i)
    # 网页队列，长度为不限量
    html_queue = Queue()

    # 网页爬取线程集合，名称以及保存线程的集合
    crawl_thread_name = ['爬取线程1', '爬取线程2', '爬取线程3']
    crawl_thread_list = []

    # 解析线程集合，名称以及保存线程的集合
    parse_thread_name = ['解析线程1', '解析线程2', '解析线程3']
    parse_thread_list = []

    # 将解析到的数据以json的形式保存到本地文件里面
    file = open('qiushi_data.json', 'a', encoding='utf-8')

    # 为了保证文件保存到本地的时候不会出现顺序出错的情况，得给文件相关的读写操作加锁
    lock = threading.Lock()

    # 开始进行网页爬取,创建对应名称的线程并且启动，并将其保存起来
    for crawl_thread in crawl_thread_name:
        thread = ThreadCrawl(crawl_thread, page_queue, html_queue)
        thread.start()
        crawl_thread_list.append(thread)

    # 开始进行网页解析
    for parse_thread in parse_thread_name:
        thread = ThreadParse(parse_thread, html_queue, file, lock)
        thread.start()
        parse_thread_list.append(thread)

    # 先进行网页爬取，必须得等待所有的网页都爬取下来之后才能进行相应的网页解析
    # 所以主线程得等待页面队列为空才能执行下一步，接下来便通知全局变量修改
    # 让网页爬取线程可以停止工作了
    while not page_queue.empty():
        pass
    global CRAWL_EXIT
    CRAWL_EXIT = True

    # 必须得将创建的线程加入到主线程中来，保证主线程等待子线程结束之后才退出,将其变为守护线程
    for thread in crawl_thread_list:
        thread.join()

    # 程序必须等待解析线程执行完之后才能进行退出，因此程序必须得等待网页队列为空
    # 在网页队列为空之后便可以进行通知全局变量，解析线程可以结束了
    while not page_queue.empty():
        pass
    global PARSE_EXIT
    PARSE_EXIT = True

    # 必须得将创建的线程加入到主线程中来，保证主线程等待子线程结束之后才退出,将其变为守护线程
    for thread in parse_thread_list:
        thread.join()

    # 程序结束,关闭文件
    print('运行完成，谢谢使用')
    with lock:
        file.close()


if __name__ == '__main__':
    main()