爬虫-----生产者与消费者模式（含源码）

        当我们引入多线程爬取内容时，难免会出现资源竞争的问题，而我们解决这个问题的方法就是能不能让一个线程去访问这个资源，而其他的等待这个资源访问。相当于你去公共测试上厕所，现在有5个位置都有人，只要有一个位置的人出来你就能接上。这个5个位置相当于5个线程，而你就相当于此时线程完成的任务。

1. 线程锁：

        当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制 某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

我们使用下面的方法就能构建出一个线程锁

创建锁：
mutex = threading.Lock()

锁定：
mutex.acquire()

解锁：
mutex.release()

案例代码：

import threading
num = 0

def demo1(nums):
    lock.acquire()
    global num
    for i in range(nums):
        num += 1
    print(f'demo1--num--{num}')
    lock.release()

def demo2(nums):
    lock.acquire()
    global num
    for i in range(nums):
        num += 1
    print(f'demo2--num--{num}')
    lock.release()

def main():
    t1 = threading.Thread(target=demo1, args=(1000000,))
    t2 = threading.Thread(target=demo2, args=(1000000,))
    t1.start()
    t2.start()
    print(f'main--num--{num}')

if __name__ == '__main__':
    lock = threading.Lock()
    main()

        我现在有两个线程t1和t2，我要执行两个任务分别是demo1和demo2，由于我这个任务是循环10000000，因此两个线程同时执行必然会发生资源竞争，因为计算机一秒是10^6，为了解决资源竞争我给两个任务分别上了一把锁，这样就避免了资源竞争。

2. Queue线程：

        在线程中，访问一些全局变量，加锁是一个经常的过程。如果你是想把一些数据存储到某个队列中，那么Python内置了一个线程安全的模块叫做queue模块。Python中的queue模块中提供了同步的、线程安全的队列类，包括FIFO（先进先出）队列Queue，LIFO（后入先出）队列LifoQueue。这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么都做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

Queue(maxsize)：创建一个先进先出的队列。
empty()：判断队列是否为空。
full()：判断队列是否满了。
get()：从队列中取最后一个数据。
put()：将一个数据放到队列中。

3. 生产者与消费者模式

        生产者和消费者模式是多线程开发中常见的一种模式。通过生产者和消费者模式，可以让代码达到高内聚低耦合的目标，线程管理更加方便，程序分工更加明确。 生产者的线程专门用来生产一些数据，然后存放到容器中(中间变量)。消费者在从这个中间的容器中取出数据进行消费。

以上图为例 

具体的流程是：首先生产者此时有3个线程，它们会将自己解析的结果保存到一个容器里面，然后让消费者去获取，此时消费者的3个线程就会解析这个结果。

下面是一个代码案例：

# -*- coding:utf-8 -*-
import re
import threading
import requests
from queue import Queue
from urllib.request import urlretrieve
headers={
    'User-Agent':'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Mobile Safari/537.36'
}


class Produce(threading.Thread):
    def __init__(self,page_queue,img_queue):
        # 使用super继承父类的初始化方法
        super().__init__()
        self.page_queue = page_queue
        self.img_queue = img_queue

    # run方法必须构建，这个是继承父类方法，相当于你这个类的主函数，run方法自动运行
    def run(self):
        while True:
            if self.page_queue.empty():
                break
            url = self.page_queue.get()
            # print(url)
            self.parse_data(url)

    def parse_data(self,url):           # 数据解析函数
        # 使用线程锁，避免资源竞争
        lock.locked()
        response = requests.get(url,headers)
        response.encoding = 'utf-8'
        response = response.text
        data_list = re.findall('<a class="name" href="(.*?)"  title="(.*?)" target="_blank">.*?</a>',response,re.S)
        # print(data_list)
        for href,title in data_list:
            new_href = 'https://sc.chinaz.com/' + href
            new_title = re.sub('[\/:*?<>|]','',title)
            response = requests.get(new_href,headers).text
            png_name = re.findall('<p js-do="shareBtn" data-txt="(.*?)">',response,re.S)[0]
            # print(new_title,png_name)
            self.img_queue.put((new_title,png_name))



class Consumer(threading.Thread):
    def __init__(self,img_queue):
        super().__init__()
        self.img_queue = img_queue

    def run(self):
        while True:  # 让我们创建的三个生产者一直工作
            if self.img_queue.empty():
                break
            else:
                img_data = self.img_queue.get()  # 元组类型数据
            filename, img_url = img_data
            urlretrieve(img_url, f'image/{filename}.jpg')
            print(f'{filename}.jpg下载成功！')


if __name__ == '__main__':
    # 创造一个线程锁
    lock = threading.Lock()
    # 构建存储页面的队列
    page_queue = Queue()
    # 构建保存照片信息的队列
    img_queue = Queue()
    for page in range(1,11):
        url = f'https://sc.chinaz.com/tupian/siwameinvtupian_{page}.html'
        page_queue.put(url)             # 将每页的url 存储到页面队列中

    # 用于解决资源竞争，保证每个线程都不会受到其他线程的打扰
    p_list = []
    
    # 使用一个循环构建3个生产者线程
    for i in range(3):
        t1 = Produce(page_queue,img_queue)
        t1.start()
        p_list.append(t1)
    
    # 使用join将每一个线程都独立运作
    for p in p_list:
        p.join()
    
    # 使用循环构建3个消费者队列
    for j in range(3):
        t2 = Consumer(img_queue)
        t2.start()