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

Python多线程编程：深入理解threading模块及代码实战

在Python编程中，多线程是一种常用的并发编程方式，它可以有效地提高程序的执行效率，特别是在处理I/O密集型任务时。Python提供了threading模块，使得多线程编程变得相对简单。本文将深入探讨threading模块的基础知识，并通过实例演示多线程的应用。

在这里插入图片描述

1. 多线程基础概念

在开始之前，让我们先了解一些多线程编程的基本概念：

  • 线程（Thread）：是操作系统能够进行运算调度的最小单位，通常在一个进程内部。
  • 多线程（Multithreading）：是指在同一程序中同时运行多个线程。
  • GIL（Global Interpreter Lock）：Python解释器的全局解释器锁，限制同一时刻只能有一个线程执行Python字节码，因此在CPU密集型任务中，多线程并不能充分利用多核处理器。

2. threading模块基础

threading模块提供了创建和管理线程的工具。以下是一些常用的threading模块中的类和函数：

  • Thread类：用于创建线程的类，通过继承Thread类并实现run方法来定义线程的执行逻辑。
  • start()方法：启动线程。
  • join()方法：等待线程执行结束。
  • active_count()函数：获取当前活动线程的数量。

3. 代码实战：多线程下载图片

下面通过一个实例来演示多线程的应用，我们将使用多线程来下载一系列图片。

import threading
import requests
from queue import Queue

class ImageDownloader:
    def __init__(self, urls):
        self.urls = urls
        self.queue = Queue()

    def download_image(self, url):
        response = requests.get(url)
        if response.status_code == 200:
            filename = url.split("/")[-1]
            with open(filename, "wb") as f:
                f.write(response.content)
            print(f"Downloaded: {filename}")

    def worker(self):
        while True:
            url = self.queue.get()
            if url is None:
                break
            self.download_image(url)
            self.queue.task_done()

    def start_threads(self, num_threads=5):
        threads = []
        for _ in range(num_threads):
            thread = threading.Thread(target=self.worker)
            thread.start()
            threads.append(thread)

        for url in self.urls:
            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")
  1. 使用cProfile模块：cProfile是Python的性能分析工具，可以帮助查看函数调用及执行时间。
import cProfile

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

# 运行性能分析
cProfile.run("my_function()")
  1. 使用第三方工具：一些第三方工具，如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. 异步编程的异常处理

在异步编程中，异常的处理方式也有所不同。在协程中，我们通常使用try-except块或者asyncio.ensure_future等方式来处理异常。

import asyncio

async def my_coroutine():
    try:
        # 异步操作
        await asyncio.sleep(1)
        raise ValueError("An error occurred")
    except ValueError as e:
        print(f"Caught an exception: {e}")

async def main():
    task = asyncio.ensure_future(my_coroutine())
    await asyncio.gather(task)

if __name__ == "__main__":
    asyncio.run(main())

在这个例子中，asyncio.ensure_future将协程包装成一个Task对象，通过await asyncio.gather等待任务执行完毕，捕获异常。

23. 异步编程的优势与注意事项

优势

  1. 高并发性： 异步编程适用于大量I/O密集型任务，能够更高效地处理并发请求，提高系统的吞吐量。

  2. 资源效率： 相较于多线程，异步编程通常更节省资源，因为协程是轻量级的，可以在一个线程中运行多个协程。

注意事项

  1. 阻塞操作： 异步编程中，阻塞操作会影响整个事件循环，应尽量避免使用阻塞调用。

  2. 异常处理： 异步编程的异常处理可能更加复杂，需要仔细处理协程中的异常情况。

  3. 适用场景： 异步编程更适用于I/O密集型任务，而不是CPU密集型任务。

24. 探索更多异步编程工具和库

除了asyncio和aiohttp之外，还有一些其他强大的异步编程工具和库：

  • asyncpg： 异步PostgreSQL数据库驱动。
  • aiofiles： 异步文件操作库。
  • aiohttp： 异步HTTP客户端和服务器框架。
  • aiomysql： 异步MySQL数据库驱动。
  • uvloop： 用于替代标准事件循环的高性能事件循环。

25. 持续学习与实践

异步编程是一个广泛且深入的主题，本文只是为你提供了一个简要的介绍。建议深入学习asyncio模块的文档，理解事件循环、协程、异步操作等概念。

同时，通过实际项目的实践，你将更好地理解和掌握异步编程的技术和最佳实践。

总结：

本文深入探讨了Python中的多线程编程和异步编程，涵盖了多线程模块（threading）的基础知识、代码实战，以及异步编程模块（asyncio）的基本概念和使用。我们从多线程的基础，如Thread类、锁机制、线程安全等开始，逐步展示了多线程在实际应用中的应用场景和注意事项。通过一个实例展示了多线程下载图片的过程，强调了线程安全和异常处理的重要性。

随后，本文引入了异步编程的概念，通过协程、async和await关键字，以及asyncio模块的使用，向读者展示了异步编程的基础。通过一个异步下载图片的实例，强调了异步编程在处理I/O密集型任务中的高效性。

文章还对异步编程的异常处理、优势与注意事项进行了详细讨论，同时介绍了一些常用的异步编程工具和库。最后，鼓励读者通过不断学习、实践，深化对多线程和异步编程的理解，提高在并发编程方面的能力。

无论是多线程编程还是异步编程，都是提高程序并发性、性能和响应性的关键技术。通过深入理解这些概念，读者可以更好地应对现代编程中复杂的并发需求，提升自己的编程水平。祝愿读者在多线程和异步编程的学习过程中取得丰硕的成果！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/416619.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

设置django orm 模型中的字段限制数值的大小

设置django orm 模型中的字段限制数值的大小

需求如下： 1：使用了django框架中的orm模式来创建数据表 2：限制字段的取值范围 # -------------------- # 因为django的orm没有限制整形字段的取值范围，所以需要django内置的值校验器进行校验 from django.core.validators i…
阅读更多...
刷题第2天（中等题）：LeetCode59--螺旋矩阵--考察模拟能力（边界条件处理）

刷题第2天（中等题）：LeetCode59--螺旋矩阵--考察模拟能力（边界条件处理）

LeetCode59: 给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。 示例 1： 输入：n 3 输出：[[1,2,3],[8,9,4],[7,6,5]]示例 2： 输入&#xff1a…
阅读更多...
Appium手机Android自动化

Appium手机Android自动化

目录 介绍 什么是APPium？ APPium的特点 环境准备 adb(android调试桥)常用命令 appium图形化简单使用 连接手机模拟器 使用appium桌面端应用程序 ​编辑 整合java代码测试 环境准备 引入所需依赖 书写代码简单启动 ​编辑 Appium元素定位 id定位 介…
阅读更多...
docker版本 jenkins配置gitlab自动部署

docker版本 jenkins配置gitlab自动部署

前端项目 Build steps pwd npm config set registry https://registry.npm.taobao.org npm -v node -v #npm install npm run build:prod tar -czvf QASystem.tar.gz distpwd cd /data/zhouxy37/vue_deploy tar -zxvf QASystem.tar.gz sudo mv dist QASystem cp -r QASyste…
阅读更多...
Matlab: Introduction to Hybrid Beamforming

Matlab: Introduction to Hybrid Beamforming

文章目录 来源混合波束赋形的基本概念System Setup关键函数 来源 在matlab的命令行输入 doc hybrid beamforming 混合波束赋形的基本概念 混合波束形成简介 本例介绍了混合波束形成的基本概念，并说明了如何模拟这种系统。 现代无线通信系统使用空间复用来提高散…
阅读更多...
WiFi模块赋能智能手表：拓展功能与提升连接性

WiFi模块赋能智能手表：拓展功能与提升连接性

随着科技的不断进步，智能手表正逐渐成为现代人生活中不可或缺的智能配饰。其中，WiFi模块的应用为智能手表带来了更多强大的功能和更高的连接性，为用户提供了更为便捷、智能化的使用体验。本文将深入探讨WiFi模块在智能手表中的应用。 远程通信…
阅读更多...
Linux入门攻坚——16、Linux系统启动流程

Linux入门攻坚——16、Linux系统启动流程

CentOS5、6的启动流程 Linux：kernel rootfs，Linux系统就是内核加上根文件系统。 内核之上是库： 库：函数集合，function，函数具有调用接口，库函数不能单独执行，必须被其他程序调用…
阅读更多...
管理系统提升：如何从用户体验设计上发力

管理系统提升：如何从用户体验设计上发力

一、关于用户体验 管理系统的用户体验（User Experience, UX）是指用户在使用管理系统时所感受到的整体体验，包括用户对系统界面、交互、功能、性能等方面的感受和评价。一个好的管理系统的用户体验应该是简单易用、高效快捷、信息清晰、界面美…
阅读更多...
Redis冲冲冲——Redis的主从复制，哨兵模式以及SpringBoot的配置

Redis冲冲冲——Redis的主从复制，哨兵模式以及SpringBoot的配置

目录 引出Redis的主从复制，哨兵模式以及SpringBoot的配置Redis的主从复制Redis的哨兵模式SpringBoot配置 缓存三兄弟：缓存击穿、穿透、雪崩缓存击穿缓存穿透缓存雪崩 总结 引出 Redis冲冲冲——Redis的主从复制，哨兵模式以及SpringBoot的配置…
阅读更多...
Matlab进阶绘图第41期—双三角网格曲面图

Matlab进阶绘图第41期—双三角网格曲面图

在《Matlab论文插图绘制模板第67期—三角网格图(Trimesh)》中，我分享过三角网格曲面图的绘制模板。 然而，有的时候，需要在一张图上绘制两个及以上的三角网格曲面图，且每个三角网格曲面图使用不同的配色方案。 在Matlab中&#x…
阅读更多...
上线服务时遇到的一个SSLHandshakeException错误

上线服务时遇到的一个SSLHandshakeException错误

今天部署自己的一个程序，在本地是可以正常跑通流程了，但是部署到服务器上运行之后出现了如下错误。 Caused by: javax.net.ssl.SSLHandshakeException: No appropriate protocol (protocol is disabled or cipher suites are inappropriate) at sun.sec…
阅读更多...
s-table和columns初始化不完整，造成table文件的filter报错

s-table和columns初始化不完整，造成table文件的filter报错

问题 顺藤摸瓜找errorHandler.js文件 发现文件并没有什么问题 顺藤摸瓜找index.vue文件 首先找到报错的filter，发现与columnsSetting相关 找到columnsSetting发现等于columns 返回自己使用S-table组件的地方，发现columns初始化时仅初始化为ref()未表明…
阅读更多...
Zoho Bigin 2024新功能预览：小企业CRM大热卖！

Zoho Bigin 2024新功能预览：小企业CRM大热卖！

目前，市面上大多数CRM客户关系管理软件功能复杂，层级多，涵盖从市场营销、销售过程管理再到售后服务的完整客户生命周期。很多功能小微企业在当前阶段用不上，所以不愿意为用不上的功能和服务付费，市场上真正适合小微企业…
阅读更多...
机器人内部传感器阅读梳理及心得-速度传感器-数字式速度传感器

机器人内部传感器阅读梳理及心得-速度传感器-数字式速度传感器

在机器人控制系统中，增量式编码器既可以作为位置传感器测量关节相对位置，又可作为速度传感器测量关节速度。当作为速度传感器时，既可以在模拟量方式下使用，又可以在数字量方式下使用。 模拟式方法 在这种方式下，需要…
阅读更多...
美国1月PCE数据出炉，5月降息成泡影？

美国1月PCE数据出炉，5月降息成泡影？

KlipC报道：周三，美国商务部发布的数据显示，美国四季度核心个人消费支出(PCE)物价指出环比修正值为2.1%，超市场预期。剔除食品和能源的核心PCE指数走高2.1%。两者均略高于预估初值。数据发布后，美元指数短线小幅走低&am…
阅读更多...
如何在宝塔面板中设置FTP文件传输服务并实现远程文件管理

如何在宝塔面板中设置FTP文件传输服务并实现远程文件管理

文章目录 1. Linux安装Cpolar2. 创建FTP公网地址3. 宝塔FTP服务设置4. FTP服务远程连接小结 5. 固定FTP公网地址6. 固定FTP地址连接 宝塔FTP是宝塔面板中的一项功能，用于设置和管理FTP服务。通过宝塔FTP，用户可以创建FTP账号，配置FTP用户权限…
阅读更多...
Linux小项目：在线词典开发

Linux小项目：在线词典开发

在线词典介绍 流程图如下： 项目的功能介绍 在线英英词典项目功能描述用户注册和登录验证服务器端将用户信息和历史记录保存在数据中。客户端输入用户和密码，服务器端在数据库中查找、匹配，返回结果单词在线翻译根据客户端输入输入的单词在字…
阅读更多...
如何将动态IP代理转换为静态IP代理的方法与步骤

如何将动态IP代理转换为静态IP代理的方法与步骤

目录 前言 一、什么是动态IP代理 二、为什么需要静态IP代理 三、如何将动态IP代理转换为静态IP代理 步骤一：购买静态IP地址 步骤二：配置代理服务器 步骤三：验证静态IP代理 步骤四：测试代理服务器 四、代码示例 五、总结…
阅读更多...
代理IP安全问题：在国外使用代理IP是否安全

代理IP安全问题：在国外使用代理IP是否安全

目录 前言 一、国外使用代理IP的安全风险 1. 数据泄露 2. 恶意软件 3. 网络攻击 4. 法律风险 二、保护国外使用代理IP的安全方法 1. 选择可信的代理服务器 2. 使用加密协议 3. 定期更新系统和软件 4. 注意网络安全意识 三、案例分析 总结 前言 在互联网时代&…
阅读更多...
C++如何跨模块释放内存

C++如何跨模块释放内存

这篇文章主要为大家详细介绍了C中跨模块释放内存的相关知识,文中的示例代码讲解详细,具有一定的借鉴价值,有需要的小伙伴可以了解下 目录 一、MT改MD二、DLL提供释放接口三、使用进程堆申请内存 在开发主程序和动态库时，首要原则就是：避免跨模块申请和…
阅读更多...
最新文章

Copyright @ 2022~2023