python多进程教学-超多模版例子代码

Python 多进程教程

Python提供了许多多进程处理模块，可以帮助我们实现并行计算，提高程序的运行效率。在本教程中，我们将介绍Python的多进程处理模块multiprocessing的基本用法。

什么是多进程？

进程是操作系统中运行的程序的实例，每个进程都有自己独立的内存空间和系统资源。多进程指的是同时运行多个进程，每个进程都可以独立执行任务。与多线程不同，多进程可以利用多个CPU核心进行并行计算，从而更快地完成任务。

multiprocessing模块的基本用法

multiprocessing模块提供了一个Process类，可以用来创建进程。我们可以通过继承Process类来定义自己的进程类。下面是一个简单的例子：

from multiprocessing import Process

class MyProcess(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(f"Hello, {self.name}!")

if __name__ == '__main__':
    p = MyProcess("World")
    p.start()
    p.join()

在这个例子中，我们定义了一个MyProcess类，它继承自Process类，并重写了run()方法。在run()方法中，我们打印出了"Hello, World!"。

在主程序中，我们首先创建了一个MyProcess实例p，然后调用了p.start()方法来启动进程。最后调用p.join()方法等待进程完成。需要注意的是，在Windows系统中，必须在if name == 'main’语句块中创建和启动进程，否则会出现错误。

进程池

在实际应用中，我们通常需要创建多个进程来并行处理任务。如果每次都创建一个新的进程，会消耗大量的系统资源，而且也会影响程序的性能。为了解决这个问题，Python提供了进程池的概念。进程池可以预先创建多个进程，然后将任务分配给这些进程，从而减少了进程的创建和销毁时间，提高了程序的运行效率。

在Python中，我们可以使用multiprocessing模块中的Pool类来创建进程池。下面是一个简单的例子：

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(f, [1, 2, 3, 4, 5]))

在这个例子中，我们首先定义了一个函数f(x)，它返回x的平方。然后我们创建了一个进程池，其中包含5个进程。我们调用p.map(f, [1, 2, 3, 4, 5])方法，将任务分配给进程池中的进程进行并行计

多进程例子

例子1：计算密集型任务

在计算密集型任务中，程序需要进行大量的计算，例如求解复杂的数学问题、加密/解密数据等。由于计算量很大，使用单进程可能会导致程序运行缓慢。我们可以使用多进程来加速计算过程。

import time
import multiprocessing

def calculate(number):
    result = 0
    for i in range(number):
        result += i
    return result

if __name__ == '__main__':
    start_time = time.time()
    with multiprocessing.Pool() as pool:
        results = pool.map(calculate, [50000000, 50000000, 50000000])
    end_time = time.time()
    print(f'Total time: {end_time - start_time:.2f} seconds')
    print(f'Results: {results}')

在这个例子中，我们定义了一个calculate函数，它接受一个数字作为参数，然后使用一个for循环计算从0到该数字的和。我们使用multiprocessing.Pool()创建一个进程池，然后使用pool.map()方法将计算任务分配给进程池中的进程进行并行计算。最后我们将计算结果打印出来。

例子2：IO密集型任务

在IO密集型任务中，程序需要进行大量的IO操作，例如读写文件、网络通信等。由于IO操作通常比计算操作更慢，使用单进程可能会导致程序运行缓慢。我们可以使用多进程来充分利用系统资源，提高程序的运行效率。

import time
import multiprocessing

def download(url):
    print(f'Starting download: {url}')
    time.sleep(2)
    print(f'Finished download: {url}')

if __name__ == '__main__':
    urls = ['https://www.python.org/', 'https://www.google.com/', 'https://www.github.com/']
    start_time = time.time()
    with multiprocessing.Pool() as pool:
        pool.map(download, urls)
    end_time = time.time()
    print(f'Total time: {end_time - start_time:.2f} seconds')

在这个例子中，我们定义了一个download函数，它接受一个URL作为参数，然后模拟下载操作。我们使用multiprocessing.Pool()创建一个进程池，然后使用pool.map()方法将下载任务分配给进程池中的进程进行并行下载。最后我们将下载的总时间打印出来。

例子3：共享内存

在多进程编程中，每个进程都有自己独立的内存空间，无法直接访问其他进程的内存。如果多个进程需要共享数据，可以使用共享内存的方式。共享内存允许多个进程访问同一块内存空间，从而实现数据共享。

import multiprocessing

def increment(counter):
    for i in range(100000):
        counter.value += 1

if __name__ == '__main__':
    counter = multiprocessing.Value('i', 0)
    processes = []

进程池例子

例子1：爬虫程序

在爬虫程序中，我们需要从多个网站中抓取数据。由于每个网站的响应时间可能不同，因此使用单进程进行抓取可能会导致程序运行缓慢。我们可以使用进程池来并行抓取数据。

import multiprocessing
import requests

def download(url):
    response = requests.get(url)
    return response.text

if __name__ == '__main__':
    urls = ['https://www.python.org/', 'https://www.google.com/', 'https://www.github.com/']
    with multiprocessing.Pool() as pool:
        results = pool.map(download, urls)
    for result in results:
        print(result[:50])

在这个例子中，我们定义了一个download函数，它接受一个URL作为参数，然后使用requests模块抓取网页内容。我们使用multiprocessing.Pool()创建一个进程池，然后使用pool.map()方法将抓取任务分配给进程池中的进程进行并行抓取。最后我们将抓取的结果打印出来。

例子2：图片处理程序

在图片处理程序中，我们需要对多个图片进行处理。由于处理每个图片可能需要较长时间，因此使用单进程进行处理可能会导致程序运行缓慢。我们可以使用进程池来并行处理图片。

import multiprocessing
from PIL import Image

def process_image(filename):
    with Image.open(filename) as image:
        image = image.rotate(90)
        image = image.resize((500, 500))
        image.save(f'processed_{filename}')

if __name__ == '__main__':
    filenames = ['image1.jpg', 'image2.jpg', 'image3.jpg']
    with multiprocessing.Pool() as pool:
        pool.map(process_image, filenames)

在这个例子中，我们定义了一个process_image函数，它接受一个文件名作为参数，然后使用PIL模块进行图片处理。我们使用multiprocessing.Pool()创建一个进程池，然后使用pool.map()方法将处理任务分配给进程池中的进程进行并行处理。

例子3：并行计算程序

在并行计算程序中，我们需要对大量的数据进行计算。由于计算量很大，使用单进程进行计算可能会导致程序运行缓慢。我们可以使用进程池来并行计算数据。

import multiprocessing

def calculate(number):
    result = 0
    for i in range(number):
        result += i
    return result

if __name__ == '__main__':
    numbers = [10000000, 20000000, 30000000]
    with multiprocessing.Pool() as pool:
        results = pool.map(calculate, numbers)
    print(f'Results: {results}')

在这个例子中，我们定义了一个calculate函数，它接受一个数字作为参数，然后使用一个for循环计算从0到该数字的和。我们使用multiprocessing.Pool()创建一个进程池，然后使用pool.map()方法将计算任务分配给进程池中的进程进行并行计