Python多线程编程：深入理解threading模块及代码实战【第99篇—Multiprocessing模块】_python multithreading模块

架构师老李华

于 2024-05-17 09:15:36 发布

阅读量299

点赞数 4

分类专栏：程序员文章标签： python 学习面试

本文链接：https://blog.csdn.net/m0_60721860/article/details/138992526

版权

程序员专栏收录该内容

190 篇文章 0 订阅

订阅专栏

文末有福利领取哦~

👉一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

👉二、Python必备开发工具

👉三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

👉 四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。（文末领读者福利）

👉五、Python练习题

检查学习结果。

👉六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

        self.queue.put(url)

    self.queue.join()

    for _ in range(num_threads):
        self.queue.put(None)

    for thread in threads:
        thread.join()

if name == “__main__”:
image_urls = [“url1”, “url2”, “url3”, …] # 替换为实际图片的URL
downloader = ImageDownloader(image_urls)
downloader.start_threads()


这个例子中，我们创建了一个`ImageDownloader`类，其中包含了一个`worker`方法，用于下载图片。通过多线程，我们能够并行地下载多张图片，提高下载效率。


#### 4. 代码解析


* `download_image`方法：负责下载图片的具体实现。
* `worker`方法：作为线程的执行逻辑，不断从队列中取出待下载的图片URL，并调用`download_image`方法。
* `start_threads`方法：启动指定数量的线程，将图片URL放入队列中，等待所有线程执行完毕。


#### 6. 线程安全与锁机制


在多线程编程中，由于多个线程同时访问共享资源，可能引发竞态条件（Race Condition）。为了避免这种情况，可以使用锁机制来确保在某一时刻只有一个线程能够访问共享资源。


`threading`模块中提供了`Lock`类，通过它可以创建一个锁，使用`acquire`方法获取锁，使用`release`方法释放锁。下面是一个简单的示例：

import threading

counter = 0
counter_lock = threading.Lock()

def increment_counter():
global counter
for _ in range(1000000):
with counter_lock:
counter += 1

def main():
thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print("Counter:", counter)

if name == “__main__”:
main()


这个例子中，我们创建了一个全局变量`counter`，并使用锁确保在两个线程同时修改`counter`时不会发生竞态条件。


#### 7. 多线程的适用场景


多线程适用于处理I/O密集型任务，如网络请求、文件读写等。在这些场景中，线程可以在等待I/O的过程中让出CPU，让其他线程有机会执行，提高程序整体效率。


然而，在处理CPU密集型任务时，由于Python的GIL，多线程并不能充分利用多核处理器，可能导致性能瓶颈。对于CPU密集型任务，考虑使用多进程编程或其他并发模型。


#### 9. 异常处理与多线程


在多线程编程中，异常的处理可能变得更加复杂。由于每个线程都有自己的执行上下文，异常可能在一个线程中引发，但在另一个线程中被捕获。为了有效地处理异常，我们需要在每个线程中使用合适的异常处理机制。

import threading

def thread_function():
try:
# 一些可能引发异常的操作
result = 10 / 0
except ZeroDivisionError as e:
print(f"Exception in thread: {e}")

if name == “__main__”:
thread = threading.Thread(target=thread_function)
thread.start()
thread.join()

print("Main thread continues...")


在这个例子中，线程`thread_function`中的除法操作可能引发`ZeroDivisionError`异常。为了捕获并处理这个异常，我们在线程的代码块中使用了`try-except`语句。


#### 10. 多线程的注意事项


在进行多线程编程时，有一些常见的注意事项需要特别关注：


* **线程安全性**：确保多个线程同时访问共享资源时不会引发数据竞争和不一致性。
* **死锁**：当多个线程相互等待对方释放锁时可能发生死锁，需要谨慎设计和使用锁。
* **GIL限制**：Python的全局解释器锁可能限制多线程在CPU密集型任务中的性能提升。
* **异常处理**：需要在每个线程中适当处理异常，以防止异常在一个线程中引发但在其他线程中未被捕获。


#### 11. 多线程的性能优化


在一些情况下，我们可以通过一些技巧来优化多线程程序的性能：


* **线程池**：使用`concurrent.futures`模块中的`ThreadPoolExecutor`来创建线程池，提高线程的重用性。
* **队列**：使用队列来协调多个线程之间的工作，实现生产者-消费者模型。
* **避免GIL限制**：对于CPU密集型任务，考虑使用多进程、`asyncio`等其他并发模型。


#### 13. 面向对象的多线程设计


在实际应用中，我们通常会面对更复杂的问题，需要将多线程和面向对象设计结合起来。以下是一个简单的例子，演示如何使用面向对象的方式来设计多线程程序：

import threading
import time

class WorkerThread(threading.Thread):
def __init__(self, name, delay):
super().init()
self.name = name
self.delay = delay

def run(self):
    print(f"{self.name} started.")
    time.sleep(self.delay)
    print(f"{self.name} completed.")

if name == “__main__”:
thread1 = WorkerThread(“Thread 1”, 2)
thread2 = WorkerThread(“Thread 2”, 1)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print("Main thread continues...")


在这个例子中，我们创建了一个`WorkerThread`类，继承自`Thread`类，并重写了`run`方法，定义了线程的执行逻辑。每个线程被赋予一个名字和一个延迟时间。


#### 14. 多线程与资源管理器


考虑一个场景，我们需要创建一个资源管理器，负责管理某个资源的分配和释放。这时，我们可以使用多线程来实现资源的异步管理。以下是一个简单的资源管理器的示例：

import threading
import time

class ResourceManager:
def __init__(self, total_resources):
self.total_resources = total_resources
self.available_resources = total_resources
self.lock = threading.Lock()

def allocate(self, request):
    with self.lock:
        if self.available_resources >= request:
            print(f"Allocated {request} resources.")
            self.available_resources -= request
        else:
            print("Insufficient resources.")

def release(self, release):
    with self.lock:
        self.available_resources += release
        print(f"Released {release} resources.")

class UserThread(threading.Thread):
def __init__(self, name, resource_manager, request, release):
super().init()
self.name = name
self.resource_manager = resource_manager
self.request = request
self.release = release

def run(self):
    print(f"{self.name} started.")
    self.resource_manager.allocate(self.request)
    time.sleep(1)  # Simulate some work with allocated resources
    self.resource_manager.release(self.release)
    print(f"{self.name} completed.")

if name == “__main__”:
manager = ResourceManager(total_resources=5)

user1 = UserThread("User 1", manager, request=3, release=2)
user2 = UserThread("User 2", manager, request=2, release=1)

user1.start()
user2.start()

user1.join()
user2.join()

print("Main thread continues...")


在这个例子中，`ResourceManager`类负责管理资源的分配和释放，而`UserThread`类表示一个使用资源的用户线程。通过使用锁，确保资源的安全分配和释放。


#### 16. 多线程的调试与性能分析


在进行多线程编程时，调试和性能分析是不可忽视的重要环节。Python提供了一些工具和技术，帮助我们更好地理解和调试多线程程序。


##### 调试多线程程序


1. **使用`print`语句**：在适当的位置插入`print`语句输出关键信息，帮助跟踪程序执行流程。
2. **日志模块**：使用Python的`logging`模块记录程序运行时的信息，包括线程的启动、结束和关键操作。
3. **pdb调试器**：在代码中插入断点，使用Python的内置调试器`pdb`进行交互式调试。

import pdb

在代码中插入断点

pdb.set_trace()


##### 性能分析多线程程序


1. **使用`timeit`模块**：通过在代码中嵌入计时代码，使用`timeit`模块来测量特定操作或函数的执行时间。

import timeit

def my_function():
# 要测试的代码

测试函数执行时间

execution_time = timeit.timeit(my_function, number=1)
print(f"Execution time: {execution_time} seconds")


2. **使用`cProfile`模块**：`cProfile`是Python的性能分析工具，可以帮助查看函数调用及执行时间。

import cProfile

def my_function():
# 要测试的代码

运行性能分析

cProfile.run(“my_function()”)


3. **使用第三方工具**：一些第三方工具，如`line_profiler`、`memory_profiler`等，可以提供更详细的性能分析信息，帮助发现性能瓶颈。

安装line_profiler

pip install line_profiler

使用line_profiler进行性能分析

kernprof -l script.py
python -m line_profiler script.py.lprof


#### 17. 多线程的安全性与风险


尽管多线程编程可以提高程序性能，但同时也带来了一些潜在的安全性问题。以下是一些需要注意的方面：


1. **线程安全性**：确保共享资源的访问是线程安全的，可以通过锁机制、原子操作等手段进行控制。
2. **死锁**：在使用锁的过程中，小心死锁的产生，即多个线程相互等待对方释放资源，导致程序无法继续执行。
3. **资源泄漏**：在多线程编程中，容易出现资源未正确释放的情况，例如线程未正确关闭或锁未正确释放。
4. **GIL限制**：在CPU密集型任务中，全局解释器锁（GIL）可能成为性能瓶颈，需谨慎选择多线程或其他并发模型。


#### 18. 探索其他并发模型


虽然多线程是一种常用的并发编程模型，但并不是唯一的选择。Python还提供了其他一些并发模型，包括：


1. **多进程编程**：通过`multiprocessing`模块实现，每个进程都有独立的解释器和GIL，适用于CPU密集型任务。
2. **异步编程**：通过`asyncio`模块实现，基于事件循环和协程，适用于I/O密集型任务，能够提高程序的并发性。
3. **并行计算**：使用`concurrent.futures`模块中的`ProcessPoolExecutor`和`ThreadPoolExecutor`，将任务并行执行。


#### 19. 持续学习与实践


多线程编程是一个广阔而复杂的领域，本文只是为你提供了一个入门的指南。持续学习和实践是深入掌握多线程编程的关键。


建议阅读Python官方文档和相关书籍，深入了解`threading`模块的各种特性和用法。参与开源项目、阅读其他人的源代码，也是提高技能的好方法。


#### 21. 多线程的异步化与协程


在现代编程中，异步编程和协程成为处理高并发场景的重要工具。Python提供了`asyncio`模块，通过协程实现异步编程。相比于传统多线程，异步编程可以更高效地处理大量I/O密集型任务，而无需创建大量线程。


##### 异步编程基础


异步编程通过使用`async`和`await`关键字来定义协程。协程是一种轻量级的线程，可以在运行时暂停和继续执行。

import asyncio

async def my_coroutine():
print(“Start coroutine”)
await asyncio.sleep(1)
print(“Coroutine completed”)

async def main():
await asyncio.gather(my_coroutine(), my_coroutine())

if name == “__main__”:
asyncio.run(main())


在上述例子中，`my_coroutine`是一个协程，使用`asyncio.sleep`模拟异步操作。通过`asyncio.gather`同时运行多个协程。


##### 异步与多线程的比较


* **性能：** 异步编程相较于多线程，可以更高效地处理大量的I/O密集型任务，因为异步任务在等待I/O时能够让出控制权，不阻塞其他任务的执行。
* **复杂性：** 异步编程相对于多线程来说，编写和理解的难度可能较大，需要熟悉协程的概念和异步编程的模型。


##### 示例：异步下载图片


以下是一个使用异步编程实现图片下载的简单示例：

import asyncio
import aiohttp

async def download_image(session, url):
async with session.get(url) as response:
if response.status == 200:
filename = url.split(“/”)[-1]
with open(filename, “wb”) as f:
f.write(await response.read())
print(f"Downloaded: {filename}")

async def main():
image_urls = [“url1”, “url2”, “url3”, …] # 替换为实际图片的URL
async with aiohttp.ClientSession() as session:
tasks = [download_image(session, url) for url in image_urls]
await asyncio.gather(*tasks)

if name == “__main__”:
asyncio.run(main())


在这个例子中，通过`aiohttp`库创建异步HTTP请求，`asyncio.gather`并发执行多个协程。


#### 22. 异步编程的异常处理




### 一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。



![](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)



### 二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。



![](https://img-blog.csdnimg.cn/img_convert/8c4513c1a906b72cbf93031e6781512b.png)



### 三、入门学习视频



我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。



![](https://img-blog.csdnimg.cn/afc935d834c5452090670f48eda180e0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5aqb56eD56eD,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center)




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618317507)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

架构师老李华

关注

4
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Python多线程编程：深入理解threading模块及代码实战【第99篇—Multiprocessing模块】_python multithreading模块

👉Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。👉👉观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。👉光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。👉检查学习结果。👉。
复制链接

扫一扫