You are currently viewing Многопроцессорная обработка в Python | Набор 1 (Введение)

Многопроцессорная обработка в Python | Набор 1 (Введение)

Эта статья представляет собой краткое введение в многопроцессорную обработку на языке программирования Python.

Что такое многопроцессорная обработка?

Многопроцессорная обработка относится к способности системы поддерживать несколько процессоров одновременно. Приложения в многопроцессорной системе разбиваются на более мелкие подпрограммы, которые выполняются независимо. Операционная система распределяет эти потоки процессорам, повышая производительность системы.

Почему многопроцессорная обработка?

Рассмотрим компьютерную систему с одним процессором. Если ему назначено несколько процессов одновременно, ему придется прерывать каждую задачу и ненадолго переключаться на другую, чтобы все процессы продолжались.
Эта ситуация похожа на то, как шеф-повар работает на кухне в одиночку. Он должен выполнить несколько задач, таких как выпечка, перемешивание, замес теста и т. д.

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

Многопроцессорная система может иметь:

  • многопроцессорный, т. е. компьютер с более чем одним центральным процессором.
  • многоядерный процессор, т. е. один вычислительный компонент с двумя или более независимыми фактическими процессорами (называемыми “ядрами”).

Здесь центральный процессор может легко выполнять несколько задач одновременно, причем каждая задача использует свой собственный процессор.

Это похоже на то, как шеф-повару в прошлой ситуации помогают его помощники. Теперь они могут делить задачи между собой, и шеф-повару не нужно переключаться между своими задачами.

Многопроцессорная обработка в Python

В Python, то многопроцессорная обработка модуль включает в себя очень простой и интуитивно понятный API для разделения работы между несколькими процессами.
Рассмотрим простой пример использования многопроцессорного модуля:

# importing the multiprocessing module
import multiprocessing

def print_cube(num):
	"""
	function to print cube of given num
	"""
	print("Cube: {}".format(num * num * num))

def print_square(num):
	"""
	function to print square of given num
	"""
	print("Square: {}".format(num * num))

if __name__ == "__main__":
	# creating processes
	p1 = multiprocessing.Process(target=print_square, args=(10, ))
	p2 = multiprocessing.Process(target=print_cube, args=(10, ))

	# starting process 1
	p1.start()
	# starting process 2
	p2.start()

	# wait until process 1 is finished
	p1.join()
	# wait until process 2 is finished
	p2.join()

	# both processes finished
	print("Done!")
Square: 100
Cube: 1000
Done!

Давайте попробуем разобраться в приведенном выше коде:

  • Чтобы импортировать модуль многопроцессорной обработки, мы делаем:
import multiprocessing
  • Чтобы создать процесс, мы создаем объект класса Process. Для этого требуются следующие аргументы:
    • target: функция, которая будет выполняться процессом
    • args: аргументы, которые должны быть переданы целевой функции

Примечание: Конструктор процесса также принимает множество других аргументов, которые будут обсуждаться позже. В приведенном выше примере мы создали 2 процесса с разными целевыми функциями:

p1 = multiprocessing.Process(target=print_square, args=(10, ))
p2 = multiprocessing.Process(target=print_cube, args=(10, ))
  • Чтобы запустить процесс, мы используем способ запуска Класс процесса.
p1.start()
p2.start()
  • После запуска процессов текущая программа также продолжает выполняться. Чтобы остановить выполнение текущей программы до завершения процесса, мы используем метод join.
p1.join()
p2.join()
  • В результате текущая программа сначала дождется завершения р1 и затем р2. Как только они будут завершены, будут выполнены следующие инструкции текущей программы.

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

# importing the multiprocessing module
import multiprocessing
import os

def worker1():
	# printing process id
	print("ID of process running worker1: {}".format(os.getpid()))

def worker2():
	# printing process id
	print("ID of process running worker2: {}".format(os.getpid()))

if __name__ == "__main__":
	# printing main program process id
	print("ID of main process: {}".format(os.getpid()))

	# creating processes
	p1 = multiprocessing.Process(target=worker1)
	p2 = multiprocessing.Process(target=worker2)

	# starting processes
	p1.start()
	p2.start()

	# process IDs
	print("ID of process p1: {}".format(p1.pid))
	print("ID of process p2: {}".format(p2.pid))

	# wait until processes are finished
	p1.join()
	p2.join()

	# both processes finished
	print("Both processes finished execution!")

	# check if processes are alive
	print("Process p1 is alive: {}".format(p1.is_alive()))
	print("Process p2 is alive: {}".format(p2.is_alive()))
ID of main process: 28628
ID of process running worker1: 29305
ID of process running worker2: 29306
ID of process p1: 29305
ID of process p2: 29306
Both processes finished execution!
Process p1 is alive: False
Process p2 is alive: False
  • Основной скрипт python имеет другой идентификатор процесса, а модуль многопроцессорной обработки создает новые процессы с другими идентификаторами процессов по мере создания Объекты процесса р1 и р2. В приведенной выше программе мы используем os.getpid() функция для получения идентификатора процесса, выполняющего текущую целевую функцию.Обратите внимание, что он совпадает с идентификаторами процессов р1 и р2 которые мы получаем с помощью атрибут pid Класс процесса.
  • Каждый процесс выполняется независимо и имеет свое собственное пространство памяти.
  • Как только выполнение целевой функции завершается, процессы завершаются. В приведенной выше программе мы использовали is_alive метод Класс процесса, чтобы проверить, все еще активен процесс или нет.

Рассмотрим диаграмму ниже, чтобы понять, чем новые процессы отличаются от основного скрипта Python:

Итак, это было краткое введение в многопроцессорную обработку в Python. Следующие несколько статей будут посвящены следующим темам, связанным с многопроцессорной обработкой:

  • Обмен данными между процессами с использованием массива, значения и очередей.
  • Концепции блокировки и пула в многопроцессорной обработке

Рекомендации: