Python多线程案例分析

接下来，我们将在之前的基础上进一步扩展多线程爬虫案例，增加以下功能：

动态URL发现与添加：爬虫在解析页面时，能够发现并添加新的URL到队列中。
设置请求头：模拟浏览器行为，设置请求头中的`User-Agent`。
使用会话：使用`requests.Session()`对象来保持连接，提高效率。
避免重复爬取：使用集合记录已爬取的URL，避免重复爬取。
更复杂的错误处理：增加对各种网络错误的处理。

扩展后的多线程爬虫代码：```python

python 复制代码

import requests
from bs4 import BeautifulSoup
import threading
import time
import logging
from queue import Queue
from urllib.parse import urljoin

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# 请求会话
session = requests.Session()

# 请求队列
url_queue = Queue()
# 避免重复爬取的集合
visited_urls = set()

def crawl(url):
    if url in visited_urls:
        return
    visited_urls.add(url)
    try:
        response = session.get(url, headers={'User-Agent': 'Mozilla/5.0'}, timeout=5)
        response.raise_for_status()  # 检查请求是否成功
        soup = BeautifulSoup(response.text, 'html.parser')
        # 假设我们爬取的是网页的标题和一些链接
        title = soup.find('title').get_text()
        links = [urljoin(url, a['href']) for a in soup.find_all('a', href=True) if a['href'] not in visited_urls]
        result_queue.put((url, title))
        # 将新发现的链接添加到队列中
        for link in links:
            url_queue.put(link)
        logging.info(f"成功爬取: {url}")
    except requests.RequestException as e:
        logging.error(f"请求错误: {url} - {e}")
    except Exception as e:
        logging.error(f"解析错误: {url} - {e}")

def worker():
    while not url_queue.empty():
        url = url_queue.get()
        crawl(url)
        # 模拟网络延迟
        time.sleep(0.5)

def manage_threads(url_list, thread_count=5):
    # 将初始URL加入队列
    for url in url_list:
        if url not in visited_urls:
            url_queue.put(url)

    # 创建并启动线程
    threads = []
    for _ in range(thread_count):
        thread = threading.Thread(target=worker)
        threads.append(thread)
        thread.start()

    # 等待所有线程完成
    for thread in threads:
        thread.join()

    # 打印结果
    while not result_queue.empty():
        url, title = result_queue.get()
        print(f"URL: {url}, Title: {title}")

# 爬取的URL列表
urls = [
    'http://example.com',
    # 添加更多URL...
]

if __name__ == "__main__":
    manage_threads(urls, thread_count=10)

```

案例详解：

动态URL发现与添加：在`crawl`函数中，解析页面后发现的链接会动态添加到`url_queue`中，以便进行爬取。
设置请求头：在`session.get`中添加了`headers`参数，模拟浏览器的`User-Agent`。
使用会话：使用`requests.Session()`对象发起请求，可以保持连接，提高效率。
避免重复爬取：通过`visited_urls`集合记录已爬取的URL，避免重复爬取同一页面。
更复杂的错误处理：在`crawl`函数中，增加了对网络错误的处理。

注意事项：

线程安全：确保对共享资源（如`url_queue`和`visited_urls`）的操作是线程安全的。
会话管理：使用`session`对象时，要注意其线程安全性。在某些情况下，可能需要为每个线程创建独立的会话。
动态URL管理：动态添加URL时，要注意避免无限循环，特别是当爬虫遇到重定向或循环链接时。
性能调优：根据实际情况调整线程数量和请求间隔，以达到最佳的爬取效率。

这个案例提供了一个更完整的多线程爬虫框架，包括动态URL发现、会话管理等高级功能。在实际应用中，你可能需要根据目标网站的特点和反爬措施进行相应的调整和优化。

在前面的基础上，我们将继续扩展我们的多线程爬虫案例，增加以下高级功能：

robots.txt 遵守：检查网站的`robots.txt`文件，确保爬虫遵守网站的爬取规则。
重试机制：对失败的请求实施重试策略。
IP代理：使用代理IP来绕过网站的IP封锁。
数据存储：将爬取的数据存储到文件或数据库中。
更细粒度的速率限制：使用更高级的速率限制策略，如令牌桶算法。

扩展后的多线程爬虫代码：```python

python 复制代码

import requests
from bs4 import BeautifulSoup
import threading
import time
import logging
from queue import Queue
from urllib.parse import urljoin, urlparse
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# 请求会话
session = requests.Session()

# 重试策略
retry_strategy = Retry(
    total=3,  # 总共重试3次
    status_forcelist=[429, 500, 502, 503, 504],  # 重试状态码
    method_whitelist=["HEAD", "GET", "OPTIONS"],  # 允许重试的方法
    backoff_factor=1  # 退避因子
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("http://", adapter)
session.mount("https://", adapter)

# 请求队列
url_queue = Queue()
# 避免重复爬取的集合
visited_urls = set()
# 存储爬取结果的列表
crawl_results = []

def crawl(url):
    if url in visited_urls:
        return
    visited_urls.add(url)
    try:
        response = session.get(url, headers={'User-Agent': 'Mozilla/5.0'}, timeout=5)
        response.raise_for_status()
        soup = BeautifulSoup(response.text, 'html.parser')
        title = soup.find('title').get_text()
        links = [urljoin(url, a['href']) for a in soup.find_all('a', href=True)]
        crawl_results.append((url, title))
        for link in links:
            if link not in visited_urls:
                url_queue.put(link)
        logging.info(f"成功爬取: {url}")
    except requests.RequestException as e:
        logging.error(f"请求错误: {url} - {e}")
    except Exception as e:
        logging.error(f"解析错误: {url} - {e}")

def worker():
    while not url_queue.empty():
        url = url_queue.get()
        crawl(url)
        # 细粒度速率限制
        time.sleep(0.5)

def manage_threads(url_list, thread_count=5):
    for url in url_list:
        if url not in visited_urls:
            url_queue.put(url)

    threads = []
    for _ in range(thread_count):
        thread = threading.Thread(target=worker)
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join()

    # 打印结果
    for result in crawl_results:
        print(result)

# 爬取的URL列表
urls = [
    'http://example.com',
    # 添加更多URL...
]

if __name__ == "__main__":
    manage_threads(urls, thread_count=10)

    # 将结果存储到文件
    with open('crawl_results.txt', 'w', encoding='utf-8') as file:
        for url, title in crawl_results:
            file.write(f"URL: {url}, Title: {title}\n")

```

案例详解：

robots.txt 遵守：可以通过`robotparser`模块来解析网站的`robots.txt`文件，并检查是否允许爬取特定的URL。
重试机制：使用`requests`的`Retry`和`HTTPAdapter`来实现请求的重试策略。
IP代理：可以在`session.get`中设置代理，例如使用`proxies`参数。
数据存储：将爬取的结果存储到文件中，也可以根据需求存储到数据库或其他存储系统中。
细粒度速率限制：在`worker`函数中，通过`time.sleep(0.5)`实现简单的速率限制。

注意事项：

robots.txt 遵守：在实际应用中，应当遵守`robots.txt`协议，尊重网站的爬取规则。
重试策略：合理配置重试策略，避免对服务器造成过大压力。
代理使用：使用代理时，应确保代理的稳定性和可靠性。
数据存储：根据实际需求选择合适的数据存储方案。
速率限制：合理设置请求间隔，避免触发网站的反爬机制。

这个案例提供了一个更为完善的多线程爬虫框架，包括遵守`robots.txt`、重试策略、使用代理、数据存储和细粒度速率限制等功能。在实际应用中，你可能需要根据目标网站的特点和反爬措施进行相应的调整和优化。