devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深入浅出Python多线程、多进程和并发编程_python多进程并发

作者：知新_RL | 2024-03-02 16:05:54

赞

踩

python多进程并发

目录

1、基础概念

什么是多线程、多进程？

多线程、多进程的优缺点

常见的并发问题: 竞争条件、死锁等

2、多线程编程

Thread类及线程创建

线程同步机制: Lock、Rlock、Semaphore

线程通信: Event、Condition等

线程池的使用: ThreadPoolExecutor

示例程序：使用线程处理任务

3、多进程编程

Process类及进程创建

进程间通信: Pipe、Queue

进程池的使用: Pool

示例程序：使用进程处理任务

4、 异步编程介绍

asyncio模块及基本概念

async/await的使用

asyncio中的Future、Task

示例程序: 基于asyncio的异步网络IO

5、并发效果优化

使用线程池提高并发效率

避免不必要的锁竞争

使用异步IO提高IO操作效率

6、综合案例: 并发爬虫

7. 通用函数模板

多线程通用函数模板

多进程通用函数模板

并发通用函数模板

8、总结语：

多线程、多进程和并发编程是现代计算中的重要主题，它们在提高程序性能、优化资源利用以及解决IO阻塞等方面发挥着关键作用。本指南将带你深入了解Python中的多线程、多进程和并发编程，从基础概念到实际案例，帮助你掌握这些强大的工具。

1、基础概念

什么是多线程、多进程？

多线程和多进程是并发编程中常用的两种方式。多线程允许程序同时执行多个任务，而多进程则允许程序创建多个独立的进程，每个进程有自己的内存空间和资源。这使得我们能够充分利用多核处理器，提高程序性能。

多线程、多进程的优缺点

多线程和多进程有各自的优点和缺点。多线程的优势在于共享内存，线程间通信更为高效，但受GIL的限制，对CPU密集型任务不太友好。多进程可以避开GIL，适合CPU密集型任务，但进程间通信相对复杂。理解它们的优缺点有助于选择合适的并发模型。

常见的并发问题: 竞争条件、死锁等

并发编程面临一些常见的问题，如竞争条件（Race Condition）、死锁（Deadlock）等。竞争条件是由于多个线程或进程同时修改共享资源而导致的不确定行为，死锁则是进程相互等待对方释放资源。我们需要了解这些问题并学习如何避免它们。

2、多线程编程

在Python中，多线程编程可以通过Thread类来实现。以下是一些关键概念和技术：

Thread类及线程创建

Python的threading模块提供了Thread类，我们可以通过继承Thread类来创建线程。下面是一个简单的示例代码：

  1. import threading
  2.  
  3. def print_numbers():
  4.     for i in range(5):
  5.         print("Number:", i)
  6.  
  7. def print_letters():
  8.     for letter in 'abcde':
  9.         print("Letter:", letter)
  10.  
  11. # 创建线程
  12. thread1 = threading.Thread(target=print_numbers)
  13. thread2 = threading.Thread(target=print_letters)
  14.  
  15. # 启动线程
  16. thread1.start()
  17. thread2.start()
  18.  
  19. # 等待线程结束
  20. thread1.join()
  21. thread2.join()
  22.  
  23. print("Both threads are done!")
  24.

这个示例中，我们创建了两个线程，分别用于打印数字和字母。start()方法用于启动线程，join()方法用于等待线程结束。

线程同步机制: Lock、Rlock、Semaphore

在多线程编程中，很容易遇到竞争条件，为了避免多个线程同时修改共享资源，我们可以使用锁机制。Python的threading模块提供了多种锁类型，例如Lock、Rlock和Semaphore。下面是一个使用Lock的示例代码：

  1. import threading
  2.  
  3. counter = 0
  4. counter_lock = threading.Lock()
  5.  
  6. def increment_counter():
  7.     global counter
  8.     with counter_lock:
  9.         counter += 1
  10.  
  11. def worker():
  12.     for _ in range(1000000):
  13.         increment_counter()
  14.  
  15. # 创建多个线程
  16. threads = []
  17. for _ in range(10):
  18.     thread = threading.Thread(target=worker)
  19.     threads.append(thread)
  20.     thread.start()
  21.  
  22. # 等待所有线程完成
  23. for thread in threads:
  24.     thread.join()
  25.  
  26. print("Counter value:", counter)
  27.

在这个示例中，我们使用了一个Lock来保护counter变量，确保每次只有一个线程能够修改它。

线程通信: Event、Condition等

在多线程编程中，有时候我们需要在线程之间进行通信。Python的threading模块提供了多种线程通信的机制，包括Event、Condition等。下面是一个使用Event的示例代码：

  1. import threading
  2.  
  3. event = threading.Event()
  4.  
  5. def wait_for_event():
  6.     print("Waiting for event to be set...")
  7.     event.wait()
  8.     print("Event has been set!")
  9.  
  10. def set_event():
  11.     print("Event is about to be set...")
  12.     event.set()
  13.  
  14. # 创建线程
  15. thread1 = threading.Thread(target=wait_for_event)
  16. thread2 = threading.Thread(target=set_event)
  17.  
  18. # 启动线程
  19. thread1.start()
  20.  
  21. # 等待一段时间
  22. thread2.start()
  23. thread2.join()
  24.  
  25. # 等待thread1完成
  26. thread1.join()
  27.

在这个示例中，我们使用了Event来实现一个线程等待另一个线程设置事件的机制。

线程池的使用: ThreadPoolExecutor

在实际的多线程编程中，管理线程的生命周期和资源分配是一项重要任务。Python的concurrent.futures模块提供了ThreadPoolExecutor和ProcessPoolExecutor来管理线程池和进程池。下面是一个使用ThreadPoolExecutor的示例代码：

  1. import concurrent.futures
  2.  
  3. def worker(number):
  4.     return number * 2
  5.  
  6. # 创建线程池
  7. with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
  8.     # 提交任务
  9.     future_to_number = {executor.submit(worker, i): i for i in range(10)}
  10.  
  11.     # 获取结果
  12.     for future in concurrent.futures.as_completed(future_to_number):
  13.         number = future_to_number[future]
  14.         result = future.result()
  15.         print(f"Worker {number} result: {result}")
  16.

在这个示例中，我们创建了一个包含4个工作线程的线程池，然后提交了10个任务，每个任务都会将输入的数

值乘以2并返回。concurrent.futures.as_completed()方法用于获取已完成的任务的结果。

示例程序：使用线程处理任务

通过实际的示例程序，展示如何使用线程来处理任务，如何进行线程间的同步，以及如何使用线程池来管理资源。

  1. import threading
  2.  
  3. def print_numbers():
  4.     for i in range(5):
  5.         print("Number:", i)
  6.  
  7. def print_letters():
  8.     for letter in 'abcde':
  9.         print("Letter:", letter)
  10.  
  11. # 创建线程
  12. thread1 = threading.Thread(target=print_numbers)
  13. thread2 = threading.Thread(target=print_letters)
  14.  
  15. # 启动线程
  16. thread1.start()
  17. thread2.start()
  18.  
  19. # 等待线程结束
  20. thread1.join()
  21. thread2.join()
  22.  
  23. print("Both threads are done!")
  24.

这个示例中，我们创建了两个线程，一个用于打印数字，另一个用于打印字母。通过使用start()方法启动线程，然后使用join()方法等待线程结束。

3、多进程编程

在Python中，多进程编程可以通过Process类来实现。以下是一些关键概念和技术：

Process类及进程创建

Python的multiprocessing模块提供了Process类，我们可以通过继承Process类来创建进程。下面是一个简单的示例代码：

  1. import multiprocessing
  2.  
  3. def print_numbers():
  4.     for i in range(5):
  5.         print("Number:", i)
  6.  
  7. def print_letters():
  8.     for letter in 'abcde':
  9.         print("Letter:", letter)
  10.  
  11. # 创建进程
  12. process1 = multiprocessing.Process(target=print_numbers)
  13. process2 = multiprocessing.Process(target=print_letters)
  14.  
  15. # 启动进程
  16. process1.start()
  17. process2.start()
  18.  
  19. # 等待进程结束
  20. process1.join()
  21. process2.join()
  22.  
  23. print("Both processes are done!")
  24.

这个示例中，我们创建了两个进程，一个用于打印数字，另一个用于打印字母。通过使用start()方法启动进程，然后使用join()方法等待进程结束。

进程间通信: Pipe、Queue

在多进程编程中，进程间通信是一个重要的话题。Python的multiprocessing模块提供了多种进程间通信的机制，包括Pipe、Queue等。下面是一个使用Queue的示例代码：

  1. import multiprocessing
  2.  
  3. def producer(queue):
  4.     for i in range(5):
  5.         queue.put(i)
  6.         print("Produced:", i)
  7.  
  8. def consumer(queue):
  9.     while True:
  10.         item = queue.get()
  11.         if item is None:
  12.             break
  13.         print("Consumed:", item)
  14.  
  15. # 创建队列
  16. queue = multiprocessing.Queue()
  17.  
  18. # 创建生产者进程和消费者进程
  19. producer_process = multiprocessing.Process(target=producer, args=(queue,))
  20. consumer_process = multiprocessing.Process(target=consumer, args=(queue,))
  21.  
  22. # 启动进程
  23. producer_process.start()
  24. consumer_process.start()
  25.  
  26. # 等待生产者进程完成
  27. producer_process.join()
  28.  
  29. # 停止消费者进程
  30. queue.put(None)
  31. consumer_process.join()
  32.  
  33. print("Both processes are done!")
  34.

在这个示例中，我们创建了一个生产者进程和一个消费者进程，通过Queue来实现进程间的通信。生产者进程不断将数据放入队列，消费者进程则不断从队列中取出数据进行处理，直到生产者进程结束。

进程池的使用: Pool

在实际的多进程编程中，管理进程的生命周期和资源分配同样是一项重要任务。Python的multiprocessing模块提供了Pool来管理进程池。下面是一个使用Pool的示例代码：

  1. import multiprocessing
  2.  
  3. def worker(number):
  4.     return number * 2
  5.  
  6. # 创建进程池
  7. with multiprocessing.Pool(processes=4) as pool:
  8.     # 提交任务
  9.     results = pool.map(worker, range(10))
  10.  
  11. print("Results:", results)
  12.

在这个示例中，我们创建了一个包含4个工作进程的进程池，然后使用map()方法来并行地执行worker函数。

示例程序：使用进程处理任务

通过实际的示例程序，展示如何使用进程来处理任务，如何进行进程间的通信，以及如何使用进程池来管理资源。

  1. import multiprocessing
  2.  
  3. def print_numbers():
  4.     for i in range(5):
  5.         print("Number:", i)
  6.  
  7. def print_letters():
  8.     for letter in 'abcde':
  9.         print("Letter:", letter)
  10.  
  11. # 创建进程
  12. process1 = multiprocessing.Process(target=print_numbers)
  13. process2 = multiprocessing.Process(target=print_letters)
  14.  
  15. # 启动进程
  16. process1.start()
  17. process2.start()
  18.  
  19. # 等待进程结束
  20. process1.join()
  21. process2.join()
  22.  
  23. print("Both processes are done!")
  24.

这个示例中，我们创建了两个进程，一个用于打印数字，另一个用于打印字母。通过使用start()方法启动进程，然后使用join()方法等待进程结束。

4、 异步编程介绍

异步编程是现代并发编程的一个重要方向，Python中的asyncio模块提供了强大的异步编程支持。

asyncio模块及基本概念

asyncio是Python中用于异步编程的标准库。它基于协程（coroutine）的概念，可以帮助我们编写高效的异步代码。下面是一个简单的示例代码：

  1. import asyncio
  2.  
  3. async def main():
  4.     print("Hello")
  5.     await asyncio.sleep(1)
  6.     print("World")
  7.  
  8. # 使用asyncio运行协程
  9. asyncio.run(main())
  10.

这个示例中，我们定义了一个main协程，其中使用await asyncio.sleep(1)来模拟一个异步操作。

async/await的使用

async和await是asyncio中的关键字，帮助我们编写异步代码。async用于定义一个协程，而await用于等待一个异步操作的完成。下面是一个示例代码：

  1. import asyncio
  2.  
  3. async def factorial(number):
  4.     result = 1
  5.     for i in range(1, number + 1):
  6.         result *= i
  7.         await asyncio.sleep(1)
  8.     return result
  9.  
  10. # 使用asyncio运行协程
  11. async def main():
  12.     result = await factorial(5)
  13.     print("Factorial result:", result)
  14.  
  15. asyncio.run(main())
  16.

在这个示例中，我们定义了一个计算阶乘的协程，其中使用await asyncio.sleep(1)模拟计算过程的异步操作。

asyncio中的Future、Task

asyncio中的Future和Task是用于处理异步操作的重要工具。Future表示一个异步操作的结果，而Task表示一个协程的执行。下面是一个示例代码：

  1. import asyncio
  2.  
  3. async def factorial(number):
  4.     result = 1
  5.     for i in range(1, number + 1):
  6.         result *= i
  7.         await asyncio.sleep(1)
  8.     return result
  9.  
  10. # 使用asyncio运行协程
  11. async def main():
  12.     # 创建Task
  13.     task = asyncio.create_task(factorial(5))
  14.     print("Task created")
  15.     result = await task
  16.     print("Factorial result:", result)
  17.  
  18. asyncio.run(main())
  19.

在这个示例中，我们使用asyncio.create_task()创建一个Task来执行阶乘的协程。

示例程序: 基于asyncio的异步网络IO

通过一个实例，展示如何使用asyncio进行异步网络IO编程，以及如何处理大量的并发连接。

  1. import asyncio
  2.  
  3. async def handle_client(reader, writer):
  4.     data = await reader.read(100)
  5.     message = data.decode()
  6.     addr = writer.get_extra_info('peername')
  7.  
  8.     print("Received", message, "from", addr)
  9.  
  10.     print("Send:", message)
  11.     writer.write(data)
  12.     await writer.drain()
  13.  
  14.     print("Closing the connection")
  15.     writer.close()
  16.  
  17. async def main():
  18.     server = await asyncio.start_server(
  19.         handle_client, '127.0.0.1', 8888)
  20.  
  21.     addr = server.sockets[0].getsockname()
  22.     print('Serving on', addr)
  23.  
  24.     async with server:
  25.         await server.serve_forever()
  26.  
  27. asyncio.run(main())
  28.

在这个示例中，我们创建了一个简单的异步网络服务器，它可以同时处理多个连接。handle_client函数用于处理每个客户端连接，通过await来等待异步操作的完成。

5、并发效果优化

优化并发性能是并发编程的重要目标，本节介绍一些优化策略和技巧：

使用线程池提高并发效率

在处理并发任务时，合理使用线程池可以有效提高程序的并发处理效率。线程池维护了一组可重用的线程，这些线程可以执行我们提交的任务，避免了线程的频繁创建和销毁开销。下面是一个使用ThreadPoolExecutor的示例代码：

  1. import concurrent.futures
  2.  
  3. # 定义一个任务函数
  4. def process_data(data):
  5.     # 这里模拟一个耗时的任务
  6.     result = data * 2
  7.     return result
  8.  
  9. # 创建线程池
  10. with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
  11.     # 提交任务
  12.     data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  13.     results = executor.map(process_data, data)
  14.  
  15. # 获取结果
  16. for result in results:
  17.     print("Result:", result)
  18.

在这个示例中，我们首先定义了一个任务函数process_data，然后使用ThreadPoolExecutor创建一个包含4个线程的线程池，通过**executor.map()**方法将任务提交给线程池并获取结果。

避免不必要的锁竞争

在多线程编程中，过多的锁竞争会影响程序性能。一个常见的方法是使用细粒度的锁，以减少锁的粒度，只保护必要的资源。这里我们演示一个使用细粒度锁的示例，模拟一个计数器，同时允许多个线程进行读操作，但只有一个线程进行写操作。

  1. import threading
  2.  
  3. class Counter:
  4.     def __init__(self):
  5.         self.value = 0
  6.         self.value_lock = threading.Lock()
  7.  
  8.     def increment(self):
  9.         with self.value_lock:
  10.             self.value += 1
  11.  
  12.     def get_value(self):
  13.         return self.value
  14.  
  15. def worker(counter):
  16.     for _ in range(1000000):
  17.         counter.increment()
  18.  
  19. # 创建计数器和多个线程
  20. counter = Counter()
  21. threads = []
  22. for _ in range(10):
  23.     thread = threading.Thread(target=worker, args=(counter,))
  24.     thread.start()
  25.     threads.append(thread)
  26.  
  27. # 等待所有线程完成
  28. for thread in threads:
  29.     thread.join()
  30.  
  31. print("Counter value:", counter.get_value())
  32.

在这个示例中，我们使用Counter类来模拟一个计数器，它包含一个整数value和一个细粒度的锁value_lock来保护计数器的更新。多个线程可以同时读取计数器的值，但只有一个线程可以进行增加操作。这样，我们避免了不必要的锁竞争，提高了并发性能。

使用异步IO提高IO操作效率

在处理IO密集型任务时，使用异步IO可以显著提高效率，特别是在网络请求、文件读写等场景下。下面是一个使用asyncio来异步读取多个文件的示例：

  1. import asyncio
  2.  
  3. async def read_file(file_name):
  4.     print(f"Reading file: {file_name}")
  5.     async with open(file_name, "r") as file:
  6.         content = await file.read()
  7.         return content
  8.  
  9. async def main():
  10.     file_names = ["file1.txt", "file2.txt", "file3.txt"]
  11.     tasks = [read_file(file_name) for file_name in file_names]
  12.     results = await asyncio.gather(*tasks)
  13.     for file_name, content in zip(file_names, results):
  14.         print(f"Content of {file_name}:")
  15.         print(content)
  16.  
  17. asyncio.run(main())
  18.

在这个示例中，我们定义了一个read_file的异步函数，用于异步读取指定的文件。然后，我们通过asyncio.gather来并发执行多个文件的读取操作。这种异步IO的方式允许我们同时进行多个IO操作，从而提高IO密集型任务的效率。

6、综合案例: 并发爬虫

最后，通过一个综合案例，帮助读者将所学的并发编程知识应用于实际场景。这个案例可以涵盖多线程、多进程、异步IO等技术，同时也可以包括一些扩展的思考，如如何处理反爬虫机制、如何使用分布式爬虫等。

  1. import threading
  2. import asyncio
  3. import aiohttp
  4. from bs4 import BeautifulSoup
  5. import random
  6. import time
  7.  
  8. # 定义目标网站的URL列表
  9. target_urls = [
  10.     "<https://example.com/page1>",
  11.     "<https://example.com/page2>",
  12.     "<https://example.com/page3>",
  13.     # 添加更多页面URL
  14. ]
  15.  
  16. # 定义用户代理池
  17. user_agents = [
  18.     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
  19.     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/91.0.864.59 Safari/537.36",
  20.     # 添加更多用户代理
  21. ]
  22.  
  23. # 定义爬取任务
  24. async def crawl_url(session, url):
  25.     headers = {
  26.         "User-Agent": random.choice(user_agents)
  27.     }
  28.     async with session.get(url, headers=headers) as response:
  29.         content = await response.text()
  30.         return content
  31.  
  32. # 定义解析任务
  33. def parse_content(content):
  34.     # 使用BeautifulSoup等工具解析页面内容，提取所需信息
  35.     soup = BeautifulSoup(content, "html.parser")
  36.     # 进行信息提取操作，具体根据目标网站结构定制
  37.     # ...
  38.  
  39. # 定义爬取单个页面的流程
  40. async def process_url(url):
  41.     async with aiohttp.ClientSession() as session:
  42.         content = await crawl_url(session, url)
  43.         parse_content(content)
  44.  
  45. # 多线程并发爬取多个页面
  46. def multi_thread_crawl():
  47.     threads = []
  48.     for url in target_urls:
  49.         thread = threading.Thread(target=asyncio.run, args=(process_url(url),))
  50.         thread.start()
  51.         threads.append(thread)
  52.     for thread in threads:
  53.         thread.join()
  54.  
  55. if __name__ == "__main__":
  56.     multi_thread_crawl()
  57.

这个示例中，我们首先定义了目标网站的URL列表和用户代理池，模拟了一个爬取任务的整体流程：

  1. 使用多线程并发爬取多个页面，以提高数据收集速度。每个线程调用asyncio.run()来执行异步IO的爬取流程。
  2. 使用异步IO（aiohttp）来处理异步网络请求，避免IO等待，提高爬虫效率。crawl_url和process_url定义了异步爬取和解析的流程。
  3. 示例中使用了BeautifulSoup来解析HTML内容，具体的信息提取操作需要根据目标网站的结构进行定制。
  4. 我们模拟了一个多线程爬虫的架构，每个线程独立运行异步IO任务。这是一个简化的分布式爬虫架构的示例。
  5. 在实际爬取时，我们通常还需要处理网站的反爬虫机制，例如设置合理的爬取速度、随机切换User-Agent、处理验证码等。根据具体情况适应反爬措施。

需要注意的是，此示例是一个简化的爬虫案例，具体的爬虫任务和目标网站结构可能会有所不同。根据实际需求，我们需要适配目标网站的反爬虫机制，合理设计爬取策略，并根据目标页面的结构定制解析过程。

7. 通用函数模板

为了方便用户直接应用之前学到的多线程、多进程以及并发编程的知识，我们可以封装一些通用函数模板，供用户在实际项目中使用。下面我们将为每个功能开发一个通用函数模板。

多线程通用函数模板

  1. def run_multithreaded_task(task_func, num_threads):
  2.     """
  3.     多线程通用函数模板
  5.     :param task_func: 任务函数，该函数将在每个线程中执行
  6.     :param num_threads: 线程数量
  7.     """
  8.     # 创建线程列表
  9.     threads = []
  10.  
  11.     # 启动线程
  12.     for _ in range(num_threads):
  13.         thread = threading.Thread(target=task_func)
  14.         thread.start()
  15.         threads.append(thread)
  16.  
  17.     # 等待所有线程执行完成
  18.     for thread in threads:
  19.         thread.join()
  20.  
  21. # 使用示例
  22. def example_task():
  23.     # TODO: 在这里编写任务函数的具体实现
  24.     pass
  25.  
  26. # 启动多线程任务，假设我们需要运行5个线程
  27. run_multithreaded_task(example_task, 5)
  28.

函数说明：

  1. run_multithreaded_task函数是一个通用的多线程运行函数模板，用户只需传入任务函数和需要的线程数量，即可启动多线程任务。
  2. 用户需要在example_task函数中编写具体的任务实现，这里只是一个示例。
  3. 调用run_multithreaded_task函数，传入任务函数和线程数量即可启动多线程任务。

多进程通用函数模板

  1. def run_multiprocessed_task(task_func, num_processes):
  2.     """
  3.     多进程通用函数模板
  5.     :param task_func: 任务函数，该函数将在每个进程中执行
  6.     :param num_processes: 进程数量
  7.     """
  8.     # 创建进程列表
  9.     processes = []
  10.  
  11.     # 启动进程
  12.     for _ in range(num_processes):
  13.         process = multiprocessing.Process(target=task_func)
  14.         process.start()
  15.         processes.append(process)
  16.  
  17.     # 等待所有进程执行完成
  18.     for process in processes:
  19.         process.join()
  20.  
  21. # 使用示例
  22. def example_task():
  23.     # TODO: 在这里编写任务函数的具体实现
  24.     pass
  25.  
  26. # 启动多进程任务，假设我们需要运行3个进程
  27. run_multiprocessed_task(example_task, 3)
  28.

函数说明：

  1. run_multiprocessed_task函数是一个通用的多进程运行函数模板，用户只需传入任务函数和需要的进程数量，即可启动多进程任务。
  2. 用户需要在example_task函数中编写具体的任务实现，这里只是一个示例。
  3. 调用run_multiprocessed_task函数，传入任务函数和进程数量即可启动多进程任务。

思路说明： 通过开发这两个通用函数模板，用户可以在自己的项目中轻松使用多线程和多进程，只需编写具体的任务函数并传入合适的线程数量或进程数量，即可快速实现并发处理，提高程序的性能和效率。同时，这些通用函数模板还考虑了线程/进程的启动、执行和等待完成等关键步骤，减轻了用户的编程负担。

并发通用函数模板

  1. def run_concurrent_task(task_func, num_threads, num_processes):
  2.     """
  3.     并发通用函数模板
  5.     :param task_func: 任务函数，该函数将在每个线程或进程中执行
  6.     :param num_threads: 线程数量
  7.     :param num_processes: 进程数量
  8.     """
  9.     # 创建线程列表和进程列表
  10.     threads = []
  11.     processes = []
  12.  
  13.     # 启动线程
  14.     for _ in range(num_threads):
  15.         thread = threading.Thread(target=task_func)
  16.         thread.start()
  17.         threads.append(thread)
  18.  
  19.     # 启动进程
  20.     for _ in range(num_processes):
  21.         process = multiprocessing.Process(target=task_func)
  22.         process.start()
  23.         processes.append(process)
  24.  
  25.     # 等待所有线程执行完成
  26.     for thread in threads:
  27.         thread.join()
  28.  
  29.     # 等待所有进程执行完成
  30.     for process in processes:
  31.         process.join()
  32.  
  33. # 使用示例
  34. def example_task():
  35.     # TODO: 在这里编写任务函数的具体实现
  36.     pass
  37.  
  38. # 启动并发任务，假设我们需要运行3个线程和2个进程
  39. run_concurrent_task(example_task, num_threads=3, num_processes=2)
  40.

函数说明：

  1. run_concurrent_task函数是一个通用的并发运行函数模板，用户可以传入任务函数、线程数量和进程数量，以支持多线程和多进程的混合使用。
  2. 用户需要在example_task函数中编写具体的任务实现，这里只是一个示例。
  3. 调用run_concurrent_task函数，传入任务函数、线程数量和进程数量即可启动并发任务。

思路说明： 这个并发通用函数模板允许用户同时使用多线程和多进程，根据实际情况选择合适的线程数量和进程数量，充分利用硬件资源，提高程序的性能。在项目中，如果需要同时处理多个任务，可以使用这个通用函数模板，同时发挥多线程和多进程的优势。

8、总结语：

在本篇文章中，我们深入探讨了Python并发编程的核心概念与实践技巧。多线程、多进程、异步IO等重要主题得到了详细阐述，并通过丰富的示例代码帮助读者更好地理解这些概念。我们学习了如何利用多线程和多进程提高程序的并发处理能力，探讨了如何避免不必要的锁竞争，以及如何使用异步IO来优化IO密集型任务。

最后，我们通过一个综合案例，将所学的并发编程知识应用到一个实际的爬虫任务中。这个案例不仅巩固了我们的学习，还展示了如何应对反爬虫机制、考虑分布式爬虫架构等挑战。并发编程是解决现代计算机应用中性能瓶颈的重要工具，本文的目的是帮助你掌握这一强大技术，让你能够更好地应对多任务、高并发的编程需求。

并发编程是一个复杂而又关键的领域，需要不断实践和深入学习。希望本文能为你提供良好的起点，激发你在并发编程领域的兴趣，并帮助你构建更高效、更强大的应用。让我们一起继续探索，不断挑战并发编程的各种难题，打造出更优秀的软件，为技术世界贡献一份力量！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/181301?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号