Python 多线程和多进程高级应用指南

python爬虫(中)--多进程和多线程 前面我们见到了基本爬虫的请求、提取和保存,这是一个基本爬虫应该有的结构,那么这时候的这个爬虫有了能爬能存的能力,但是这种能力是很弱的,弱主要体现在三点:①爬虫本身健壮性并不高,有很多情况不一定考虑到;②爬虫爬的很慢,效率很低;③防反爬能力不强,容易被Ban掉 我们在这篇博文就会就上面第二点讲讲怎么通过运用多线程和多进程来提高爬虫的工作效率. 阅读详情

Python 多线程和多进程高级应用指南

1. 多线程基础

多线程是 Python 中一种并发编程方式,它允许我们在同一进程中运行多个线程。

import threading
import time

def worker():
    print(f"Worker thread started: {threading.current_thread().name}")
    time.sleep(1)
    print(f"Worker thread finished: {threading.current_thread().name}")

# 创建线程
threads = []
for i in range(3):
    t = threading.Thread(target=worker, name=f"Thread-{i}")
    threads.append(t)
    t.start()

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

print("All threads finished")

2. 多进程基础

多进程是 Python 中另一种并发编程方式,它允许我们在不同的进程中运行代码,充分利用多核 CPU。

import multiprocessing
import time

def worker():
    print(f"Worker process started: {multiprocessing.current_process().name}")
    time.sleep(1)
    print(f"Worker process finished: {multiprocessing.current_process().name}")

# 创建进程
processes = []
for i in range(3):
    p = multiprocessing.Process(target=worker, name=f"Process-{i}")
    processes.append(p)
    p.start()

# 等待所有进程完成
for p in processes:
    p.join()

print("All processes finished")

3. 线程安全

3.1 锁机制

import threading
import time

counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:
        current = counter
        time.sleep(0.1)  # 模拟计算时间
        counter = current + 1

# 创建线程
threads = []
for i in range(10):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

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

print(f"Final counter value: {counter}")

3.2 信号量

import threading
import time

# 限制同时运行的线程数
semaphore = threading.Semaphore(2)

def worker(name):
    with semaphore:
        print(f"Worker {name} started")
        time.sleep(1)
        print(f"Worker {name} finished")

# 创建线程
threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

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

print("All workers finished")

4. 进程间通信

4.1 队列

import multiprocessing
import time

def producer(queue):
    for i in range(5):
        item = f"Item {i}"
        queue.put(item)
        print(f"Produced: {item}")
        time.sleep(0.5)


def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(f"Consumed: {item}")
        time.sleep(1)

# 创建队列
queue = multiprocessing.Queue()

# 创建进程
producer_process = multiprocessing.Process(target=producer, args=(queue,))
consumer_process = multiprocessing.Process(target=consumer, args=(queue,))

# 启动进程
producer_process.start()
consumer_process.start()

# 等待生产者完成
producer_process.join()

# 发送结束信号
queue.put(None)

# 等待消费者完成
consumer_process.join()

print("All processes finished")

4.2 管道

import multiprocessing
import time

def sender(conn):
    for i in range(5):
        item = f"Message {i}"
        conn.send(item)
        print(f"Sent: {item}")
        time.sleep(0.5)
    conn.close()


def receiver(conn):
    while True:
        try:
            item = conn.recv()
            print(f"Received: {item}")
        except EOFError:
            break

# 创建管道
parent_conn, child_conn = multiprocessing.Pipe()

# 创建进程
sender_process = multiprocessing.Process(target=sender, args=(child_conn,))
receiver_process = multiprocessing.Process(target=receiver, args=(parent_conn,))

# 启动进程
sender_process.start()
receiver_process.start()

# 等待进程完成
sender_process.join()
receiver_process.join()

print("All processes finished")

5. 线程池和进程池

5.1 线程池

import concurrent.futures
import time

def worker(num):
    print(f"Worker {num} started")
    time.sleep(1)
    print(f"Worker {num} finished")
    return num * 2

# 创建线程池
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    # 提交任务
    futures = [executor.submit(worker, i) for i in range(5)]
    
    # 获取结果
    for future in concurrent.futures.as_completed(futures):
        result = future.result()
        print(f"Result: {result}")

print("All tasks completed")

5.2 进程池

import concurrent.futures
import time

def worker(num):
    print(f"Worker {num} started")
    time.sleep(1)
    print(f"Worker {num} finished")
    return num * 2

# 创建进程池
with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
    # 提交任务
    futures = [executor.submit(worker, i) for i in range(5)]
    
    # 获取结果
    for future in concurrent.futures.as_completed(futures):
        result = future.result()
        print(f"Result: {result}")

print("All tasks completed")

6. 实际应用场景

6.1 I/O 密集型任务

import concurrent.futures
import requests
import time

urls = [
    "https://www.google.com",
    "https://www.baidu.com",
    "https://www.github.com",
    "https://www.stackoverflow.com",
    "https://www.python.org"
]

def fetch_url(url):
    print(f"Fetching {url}")
    response = requests.get(url)
    return f"{url}: {response.status_code}"

# 使用线程池处理 I/O 密集型任务
start_time = time.time()

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(fetch_url, urls))

end_time = time.time()
print(f"Time taken: {end_time - start_time:.2f} seconds")
print("Results:")
for result in results:
    print(result)

6.2 CPU 密集型任务

import concurrent.futures
import time

def compute_intensive_task(n):
    print(f"Computing for {n}")
    result = 0
    for i in range(n):
        result += i * i
    return result

# 使用进程池处理 CPU 密集型任务
start_time = time.time()

with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(compute_intensive_task, [10000000] * 4))

end_time = time.time()
print(f"Time taken: {end_time - start_time:.2f} seconds")
print("Results:")
for result in results:
    print(result)

7. 最佳实践

  1. 选择合适的并发模型:对于 I/O 密集型任务,使用线程池;对于 CPU 密集型任务,使用进程池。
  2. 避免共享状态:尽量避免在多线程或多进程之间共享状态,使用队列或管道进行通信。
  3. 使用锁机制:当需要共享状态时,使用锁机制确保线程安全。
  4. 设置合理的池大小:根据系统资源和任务类型设置合理的线程池或进程池大小。
  5. 处理异常:在并发任务中正确处理异常,避免进程或线程崩溃。
  6. 使用 with 语句:使用 with 语句管理线程池和进程池,确保资源被正确释放。
  7. 测试并发性能:测试不同并发策略的性能,选择最优方案。

8. 总结

多线程和多进程是 Python 中强大的并发编程工具,它们允许我们充分利用系统资源,提高程序的运行效率。通过掌握多线程和多进程的高级应用,我们可以编写更加高效、响应迅速的代码。

在实际应用中,我们可以根据任务类型选择合适的并发模型:对于 I/O 密集型任务,使用线程池;对于 CPU 密集型任务,使用进程池。同时,我们需要注意线程安全和进程间通信等问题,确保程序的正确性和稳定性。

希望本文对你理解和应用 Python 多线程和多进程有所帮助!

Python学习之旅:高级阶段(六)多线程、多进程和异步编程比较 在 Python 高级编程中,多线程、多进程和异步编程都是提升程序运行效率的重要技术。虽然它们的目的相似,但在实现方式和适用场景上却各有不同。接下来,我们就详细对比一下这三种技术。 阅读详情

相关推荐

BRAM在图像处理缓存中的实现:完整示例解析

深入讲解如何利用BRAM高效实现图像处理中的数据缓存,结合实际案例解析BRAM的应用优势与设计细节,提升系统性能。

weixin_29443363的博客 334

Python中的多进程与多线程详解

【代码】Python中的多进程与多线程详解。

Limiiiing的博客 2646

5种超实用方法:快速获取Windows文件夹下所有文件名(含CMD/PowerShell脚本)

本文详细介绍了5种快速获取Windows文件夹下所有文件名的实用方法,包括图形界面操作、Excel数据导入、CMD命令和PowerShell脚本。特别提供了高效的CMD和PowerShell脚本示例,帮助用户轻松实现文件名的批量获取与管理,大幅提升工作效率。

opencv7vision的博客 455

python多进程中常用方法用法详解

python多进程中常用方法用法详解

IT之一小佬的博客 5195

合并数组与非合并数组——SystemVerilog

合并型数组(packed): — 合并型数组可以实现连续的存储,赋值时不需要用 '{ }。 //合并型数组 bit [3] [7:0] b_pack // 表示3行 x 8列的数组,[3]是高维度(高维度),[7:0]是低维度(第一维) 数组中,数据排列为{b_pack[3],b_pack[2],b_pack[1],b_pack[0]},其中每个b_pack为8个bit; bit是二值逻辑,每位bit只占据1位。故24位bit只占据一个word(一般一个word为32bit)的存储空间

SummerXRT的博客 7641

UOS忘记密码别慌!用LiveCD工具5分钟搞定,附命令行救援模式详细步骤

本文详细介绍了UOS系统密码遗忘时的两种解决方案:图形化LiveCD工具和命令行救援模式。针对普通用户,LiveCD工具提供5分钟快速重置密码的便捷操作;而技术人员可通过命令行深度解析系统分区挂载与密码修改流程。文章还包含安全加固建议,帮助用户预防类似问题发生。

weixin_27032989的博客 593

Python多进程的使用

1.计算密集型用多进程; 2.进程之间执行是无序的,操作系统调度哪个进程,哪个进程就先执行; 3.进程之间不共享全局变量,创建子进程时会复制父进程的全部资源; 4.主进程会等待所有子进程执行结束再结束; 5.主进程结束立马结束子进程:1.子进程对象.daemon=True,2.子进程对象.terminate(); 6.执行线程时才有GIL锁——Global Interpreter Lock。 ''' 计算密集型用多进程 进程之间执行是无序的,操作系统调度哪个进程,哪个进程就先执行 进程之间不共享全局变.

KK_2018的技术博客_程序员不止是程序员 791

【原创】关于西门子S120 的电气图纸设计

我们首先要了解一下模块的基本信息:SINAMICS 功率模块 PM240-2 三相交流380-480V+10/-10% 47-63Hz;至此,我们选择的驱动系统配置的资料都已经查找完毕,接下来就是根据每个部件的功能接口和我们需要实现的功能画出接线连接图,这样关于伺服电机控制,硬件部分设计就完成了。2)FSA - FSC 型功率模块 PM240-2 的屏蔽连接板外形尺寸图,所有数据以毫米(英寸)为单位。1)FSA 型功率模块 PM240-2 的外形尺寸图,所有数据以毫米(英寸)为单位。

Qinmingyue13的博客 2640

Python多进程应用

在我之前的一篇博文中详细介绍了Python多线程的应用: 进程,线程,GIL,Python多线程,生产者消费者模型都是什么鬼 但是由于GIL的存在,使得python多线程没有充分利用CPU的多核,为了利用多核,我可以采用多进程; 1. 父进程与子进程 wiki上对于父进程与子进程的定义: a)Parent process InUnix-likeoperating systems,...

weixin_30662539的博客 198

YOLO26 终极蒸馏指南:从入门到 SOTA (The Ultimate Distillation Guide)

《YOLO26 蒸馏技术指南》深入解析了知识蒸馏在目标检测中的应用,提出五大蒸馏范式:响应蒸馏(学习最终输出)、特征蒸馏(模仿中间特征)、关系蒸馏(捕捉通道关联)、CWD(通道语义对齐)和FGD(前景背景分离)。实验表明,"Response KD + CWD + FGD"组合效果最佳,使YOLO26n在0.5ms推理速度下达到0.956 mAP50,甚至超越教师模型。指南提供模块化代码实现和超参数调优建议,强调蒸馏能平衡模型精度与效率,是轻量化部署的有效方案。

weixin_51988935的博客 717

基于Transformer的股票市场多因子量化选股模型,深度解析:基于Transformer的股票市场多因子量化选股模型

传统多因子模型通常采用线性回归、岭回归或Lasso回归来估计因子权重,其核心假设是因子与未来收益之间存在线性关系。然而,现实中的股票市场具有典型的非线性、非平稳和高噪声特征。卷积神经网络(CNN)擅长提取局部特征,但难以捕捉全市场股票之间的全局依赖关系;循环神经网络(RNN)及其变体LSTM虽然能处理时间序列,但存在梯度消失问题且难以并行计算。Transformer的self-attention机制能够:直接建模任意两只股票之间的相关性动态计算因子权重而非静态线性组合。

YOLO 251

Python3 多线程编程学习指南

多线程是一种在同一个进程内并发执行多个线程的技术。每个线程是一个独立的执行单元,共享进程的内存和资源。多线程允许在一个应用程序中同时执行多个任务。优势:挑战:在多线程环境下,由于线程共享内存,因此线程切换比进程切换更轻量,适用于处理并发任务。Python 中的 GIL(Global Interpreter Lock)是一个锁机制,确保同一时刻只有一个线程可以执行 Python 字节码。GIL 使得 Python 在执行 CPU 密集型任务时无法充分利用多核 CPU,这意味着在多线程程序中,CPU 密集型任务

wolf23151269的博客 975

枚举 ACS 电机状态位 完全解析

本文解析了ACS运动控制器SDK中的MotorStates枚举,该枚举对应控制器状态标志位?MFLAGS。主要介绍了6个核心状态:ACSC_ALL(-1)表示所有轴,ACSC_NONE(0)为空闲状态,ACSC_MST_ENABLE(1)为轴使能,ACSC_MST_INPOS(16)表示到位,ACSC_MST_MOVE(32)为运动中,ACSC_MST_ACC(64)为加速中。文章还补充了完整的枚举定义,包含报警、回零等状态,并提供了在晶圆AOI4轴运动中的典型应用场景,如判断轴状态、运动条件等。最后强调只

StevenChen的博客 250

Python中的并发编程:多线程与多进程的高级应用

多线程是指在同一进程中运行多个线程,每个线程执行不同的任务,共享相同的内存空间。Python中的多线程通过threading模块实现,使用起来比较简单。# 创建线程# 启动线程# 等待线程结束多进程是指在操作系统中同时运行多个进程,每个进程拥有独立的内存空间和资源。Python中的多进程通过模块实现,可以利用多核处理器的优势。# 创建进程# 启动进程# 等待进程结束。

Trb601012的博客 1327

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Python中的多线程与多进程高级应用

在Python中,多线程和多进程提供了强大的并行计算能力。而对于CPU密集型任务,多进程则更为合适。在实现过程中,需要注意线程和进程间的同步、互斥以及资源共享等问题,以确保程序的正确性和稳定性。通过合理地运用多线程和多进程,我们可以提高程序的执行效率,更好地利用系统资源,为大规模数据处理和分析提供有力支持。总之,只有深入理解多线程和多进程的工作原理,并结合实际业务场景灵活运用,才能发挥出Python在并行计算方面的最大潜力。多线程更适合IO密集型任务,因为线程的创建和销毁相对轻量,且线程间的切换成本较低。

weixin_46121540的博客 900

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

Python多线程与多进程

python多线程与多进程

尚墨1111的博客 1582

Python实战:用多线程和多进程打造高效爬虫

通过使用多线程和多进程,我们可以显著提高网络爬虫的效率,更快地获取大量数据。然而,要小心线程安全问题和进程管理的开销。挑战与创造都是很痛苦的,但是很充实。

null18的博客 7576

一文掌握Python多线程与多进程

并发是今天计算机编程中的一项重要能力,尤其是在面对需要大量计算或I/O操作的任务时。Python 提供了多种并发的处理方式,本篇文章将深入探讨其中的两种:多线程与多进程,解析其使用场景、优点、缺点,并结合代码例子深入解读。

2201_75362610的博客 2815

python中多线程与多进程的区别和联系

python多线程实现 python多线程和多进程的区别 python多线程爬虫 python多线程坑 python多线程可以在windows下实现吗 python多线程并发 python多线程变量共享 python多线程是并发还是并行 python多线程实例 python多线程condition Python中多进程与多线程的区别有:线程需要在进程中执行,一个进程可包含多个线程;进程可共享同个...

大数据基础框架学习教程汇集 4342

一文带你搞清楚Python的多线程和多进程

本文介绍了在Python中使用线程池和进程池来实现并发编程的方法,并提供了相应的代码示例。

华为云官方博客 1838

Python实现多线程、多进程及协程

本文详细介绍了 Python 中多线程、多进程和协程的并发模型及其实现方式,并通过具体场景演示了如何使用面向对象思想实现这些模型。在实际应用中,应根据任务的类型和需求选择合适的并发模型,从而优化程序的性能和资源利用率。本文将详细介绍 Python 中的多线程、多进程和协程的概念及其实现方式,并通过具体场景展示如何在 Python 中使用面向对象的思想实现这些并发模型。接下来,我们通过一个计算密集型任务的示例来演示多进程的实现:计算一系列大数字的阶乘。主程序中创建并启动了多个计算进程,并使用。

闲人编程的博客 2575

python3的多进程和多线程设计实现

多线程(threading)和多进程(multiprocessing)差异

tianyuanwo的专栏 826

最强提升!Python多核CPU同时执行多进程,python多进程和多线程介绍。

随着计算机硬件的不断发展,多核CPU已经成为普及的硬件设备,利用多核CPU的优势可以有效的提高程序的执行效率。而多进程模式可以实现多核CPU的并行计算。Python作为一门高级编程语言,提供了多进程、多线程等多种方式来实现并行计算。本文将对python多进程和多线程进行分别介绍。进程是分配资源的最小单位线程是系统调度的最小单位。当应用程序运行时最少会开启一个进程,此时计算机会为这个进程开辟独立的内存空间,不同的进程享有不同的空间,而一个CPU在同一时刻只能够运行一个进程,其他进程处于等待状态。

python03011的博客 2889
上一篇: Python 数据可视化高级应用指南
下一篇: Python Web 开发高级应用指南
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值