Привет, товарищи питонисты! Вы устали ждать, пока ваш код будет выполняться последовательно, и хотите ускорить процесс? Что ж, вам повезло! В этой статье блога мы исследуем мир многопроцессорной обработки в Python 3 и узнаем, как она может революционизировать производительность вашего кода. Итак, засучите рукава и приступим!

Что такое многопроцессорность?
Многопроцессорность — это метод Python, который позволяет выполнять несколько процессов одновременно. В отличие от многопоточности, которая использует одно и то же пространство памяти, многопроцессорность позволяет использовать преимущества нескольких ядер ЦП, что делает ее идеальной для задач с интенсивными вычислениями.

Метод 1: Класс процесса
Один из способов использовать возможности многопроцессорной обработки — использовать класс Processиз модуля multiprocessing. Вот простой пример для начала:

import multiprocessing
def my_function(name):
    print(f"Hello, {name}!")
if __name__ == "__main__":
    p = multiprocessing.Process(target=my_function, args=("Alice",))
    p.start()
    p.join()

Метод 2: класс Pool
Класс Pool— еще один фантастический инструмент, предоставляемый модулем multiprocessing. Он позволяет создать пул рабочих процессов и распределить задачи между ними. Посмотрите этот фрагмент кода:

import multiprocessing
def square(x):
    return x2
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        numbers = [1, 2, 3, 4, 5]
        results = pool.map(square, numbers)
        print(results)

Метод 3. Класс Queue
Класс Queueобеспечивает удобный способ передачи данных между различными процессами. Это позволяет вам создать общую структуру данных, в которую один процесс может помещать элементы, а другой процесс может их извлекать. Взгляните на этот пример:

import multiprocessing
def producer(queue):
    for i in range(5):
        queue.put(i)
        print(f"Produced: {i}")
def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(f"Consumed: {item}")
if __name__ == "__main__":
    queue = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=producer, args=(queue,))
    p2 = multiprocessing.Process(target=consumer, args=(queue,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

Метод 4: Класс блокировки
Когда несколько процессов одновременно обращаются к общему ресурсу, могут возникнуть конфликты. Класс Lockпозволяет синхронизировать доступ к общим ресурсам, гарантируя, что только один процесс может изменять их одновременно. Вот фрагмент кода, демонстрирующий его использование:

import multiprocessing
def increment_counter(counter, lock):
    for _ in range(100000):
        with lock:
            counter.value += 1
if __name__ == "__main__":
    counter = multiprocessing.Value("i", 0)
    lock = multiprocessing.Lock()
    processes = []
    for _ in range(4):
        p = multiprocessing.Process(target=increment_counter, args=(counter, lock))
        p.start()
        processes.append(p)
    for p in processes:
        p.join()
    print(f"Counter value: {counter.value}")

Поздравляем! Вы только что окунулись в огромный океан многопроцессорной обработки в Python 3. Используя возможности параллелизма, вы можете значительно повысить производительность своего кода и решать задачи, требующие больших вычислительных ресурсов. Так что вперед, экспериментируйте с этими методами и раскройте весь потенциал своих программ на Python!