python爬虫学习(三十三天)---多线程上篇

提高爬取效率：多线程可以并行处理多个任务，使得爬虫能够同时访问和下载多个网页，从而显著缩短整体爬取时间。
充分利用资源：多线程能够充分利用计算机的多核处理器资源，使得爬虫在处理大规模爬取任务时更加高效。
减少网络延迟影响：由于网络延迟的存在，单线程爬虫在访问每个URL时都需要等待网络响应。而多线程爬虫可以同时处理多个URL，从而减少等待时间，降低网络延迟对爬取效率的影响。
实现复杂的爬取策略：多线程爬虫可以方便地实现复杂的爬取策略，如分布式爬取、优先级调度等。通过合理分配线程资源，可以实现对不同网页的优先爬取或并行爬取。

（3）多线程爬虫的实现方式

在Python中，可以使用threading模块来实现多线程爬虫。通常的做法是创建一个线程池，然后向线程池中提交任务（即访问和下载网页的任务）。线程池中的线程会并行执行这些任务，并返回结果。为了避免线程间的竞争和冲突，需要使用线程安全的队列（如queue.Queue）来管理待爬取的URL和已爬取的数据。

（4）多线程爬虫的注意事项

线程安全：多线程编程时需要注意线程安全，避免多个线程同时访问和修改共享资源导致的数据混乱和错误。可以通过使用锁（如threading.Lock）或其他同步机制来保证线程安全。
资源消耗：多线程会消耗更多的系统资源（如CPU、内存等），因此需要合理控制线程数量，避免过度消耗资源导致系统崩溃或性能下降。
网络爬虫法规：在编写多线程爬虫时需要遵守相关法律法规和网站的使用协议，不得进行恶意爬取、数据滥用等行为。
异常处理：多线程爬虫在执行过程中可能会遇到各种异常情况（如网络错误、页面结构变化等），需要编写健壮的异常处理代码来确保程序的稳定性和可靠性。

二、Python中的多线程实现

在Python中，多线程的实现主要依赖于threading模块。下面将详细介绍Python中多线程的实现，并附带示例代码。

1. 基本概念

在Python中，线程是程序执行的最小单元。多线程允许在单个程序中并发地执行多个线程。由于Python的全局解释器锁（GIL），多线程在CPU密集型任务上的并行执行效果并不明显，但在I/O密集型任务（如网络请求）中，多线程可以显著提高性能。

2. 线程创建与启动

在Python中，可以通过继承threading.Thread类并重写run方法来创建一个线程，然后调用start方法启动线程。

示例代码：

import threading  
import time  
  
def worker(name):  
    """线程执行的函数"""  
    print(f"线程 {name} 开始工作")  
    time.sleep(2)  # 模拟耗时操作  
    print(f"线程 {name} 工作完成")  
  
# 继承 threading.Thread 类  
class MyThread(threading.Thread):  
    def __init__(self, name):  
        super().__init__()  # 调用父类构造函数  
        self.name = name  
  
    def run(self):  
        """线程运行的函数"""  
        worker(self.name)  # 调用上面定义的函数  
  
# 创建并启动线程  
threads = []  
for i in range(5):  
    t = MyThread(f"Thread-{i}")  
    t.start()  # 启动线程  
    threads.append(t)  
  
# 等待所有线程完成  
for t in threads:  
    t.join()  
  
print("所有线程已完成")

3. 线程同步与互斥

由于多线程并发执行，可能会存在对共享资源的竞争访问问题。Python提供了多种同步机制来解决这个问题，如锁（Lock）、条件变量（Condition）、信号量（Semaphore）等。

示例代码：使用锁（Lock）

import threading  
  
class Counter:  
    def __init__(self):  
        self.lock = threading.Lock()  
        self.value = 0  
  
    def increment(self):  
        with self.lock:  # 使用 with 语句自动管理锁的获取和释放  
            self.value += 1  
  
# 创建多个线程，每个线程都调用 Counter 的 increment 方法  
threads = []  
counter = Counter()  
for i in range(1000):  
    t = threading.Thread(target=counter.increment)  
    t.start()  
    threads.append(t)  
  
# 等待所有线程完成  
for t in threads:  
    t.join()  
  
print(f"最终计数值：{counter.value}")  # 应该输出 1000

4. 线程池

为了避免创建过多线程导致的系统资源耗尽问题，可以使用线程池来限制同时运行的线程数量。Python的concurrent.futures模块提供了ThreadPoolExecutor类来实现线程池。

示例代码：使用线程池

import concurrent.futures  
import time  
  
def worker(n):  
    print(f"开始工作：{n}")  
    time.sleep(2)  # 模拟耗时操作  
    return f"结果：{n}"  
  
# 创建一个线程池，最大线程数为 5  
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:  
    # 提交多个任务到线程池执行  
    futures = [executor.submit(worker, i) for i in range(10)]  
  
    # 等待所有任务完成，并获取结果  
    for future in concurrent.futures.as_completed(futures):  
        try:  
            result = future.result()  
            print(result)  
        except Exception as e:  
            print(f"生成了一个异常：{e}")  
  
print("所有任务已完成")

5. 总结

Python中的多线程实现主要依赖于threading模块，通过继承threading.Thread类并重写run方法可以创建自定义的线程。同时，Python也提供了多种同步机制来解决多线程并发执行时可能存在的共享资源竞争访问问题。为了避免创建过多线程导致的系统资源耗尽问题，可以使用线程池来限制同时运行的线程数量。

三、线程安全和数据共享

线程安全和数据共享是在多线程编程中必须考虑的两个重要概念。线程安全指的是在多线程环境下，代码的执行结果总是符合预期，不会因为线程间的并发执行而导致数据不一致或其他不可预期的结果。数据共享则是指多个线程访问和操作同一块内存区域的数据。

在Python中，由于全局解释器锁（GIL）的存在，CPU密集型任务在多线程中并不会真正并行执行，但对于I/O密集型任务或外部资源的访问（如文件、网络请求等），多线程仍然可以提高程序的效率。然而，即使在这些情况下，我们也需要确保线程安全和数据共享的正确性。

线程安全

线程安全通常通过以下几种方式实现：

避免共享状态：尽量让线程只操作自己的局部变量，避免共享状态。
使用线程同步机制：如锁（Lock）、条件变量（Condition）、信号量（Semaphore）等。
使用线程安全的数据结构：Python标准库中的queue模块提供了线程安全的队列实现。

示例代码：使用锁确保线程安全

import threading  
  
class SharedCounter:  
    def __init__(self):  
        self.lock = threading.Lock()  
        self.value = 0  
  
    def increment(self):  
        with self.lock:  
            self.value += 1  
  
    def decrement(self):  
        with self.lock:  
            self.value -= 1  
  
    def get_value(self):  
        # 这里没有修改值，所以不需要加锁  
        return self.value  
  
# 创建多个线程对SharedCounter进行操作  
def worker(counter, action, n):  
    for _ in range(n):  
        if action == 'inc':  
            counter.increment()  
        elif action == 'dec':  
            counter.decrement()  
  
threads = []  
counter = SharedCounter()  
  
# 创建增加线程  
for _ in range(10):  
    t = threading.Thread(target=worker, args=(counter, 'inc', 1000))  
    threads.append(t)  
    t.start()  
  
# 创建减少线程（为了演示，这里只创建一个）  
t = threading.Thread(target=worker, args=(counter, 'dec', 500))  
threads.append(t)  
t.start()  
  
# 等待所有线程完成  
for t in threads:  
    t.join()  
  
# 输出最终值，应该接近5000（10个线程各增加1000次，1个线程减少500次）  
print(counter.get_value())

数据共享

在Python中，由于所有对象都是通过引用传递的，因此数据共享是隐式的。但是，当多个线程需要访问和修改同一块数据时，就需要考虑线程同步和数据一致性的问题。

示例代码：线程间共享数据

import threading  
  
# 共享的数据  
shared_data = {'count': 0}  
lock = threading.Lock()  
  
def increment_data():  
    global shared_data  
    for _ in range(100000):  
        with lock:  
            shared_data['count'] += 1  
  
def decrement_data():  
    global shared_data  
    for _ in range(50000):  
        with lock:  
            shared_data['count'] -= 1  
  
# 创建线程  
t1 = threading.Thread(target=increment_data)  
t2 = threading.Thread(target=decrement_data)  
  
# 启动线程  
t1.start()  
t2.start()  
  
# 等待线程完成  
t1.join()  
t2.join()  
  
# 输出最终结果，由于有线程竞争和同步，结果可能不是精确的50000  
print(shared_data['count'])

在这个例子中，我们使用了全局变量shared_data来模拟共享数据，并使用锁来确保在修改shared_data时的线程安全。需要注意的是，即使使用了锁，由于线程调度的不确定性，最终的结果可能不是精确的50000，但它应该是一个接近这个值的数。

好了，今天我们先学习多进程爬虫的三个知识点，明天我们将会学习后三个。再见啦，兄弟姐妹们。

原文地址:https://blog.csdn.net/2201_75809246/article/details/140331248 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1811339154626318336.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部