Глава 3. Параллельность на основе процессов

Во введении в документацию Python multiprocessing чётко указывается тот факт, что вся имеющаяся внутри этого пакета функциональность требует того, чтобы модуль main был доступен для импорта в его потомков (https://docs.python.org/3.3/library/multiprocessing.html).

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

> python multiprocessing_example.py
		

Здесь multiprocessing_example.py является названием соотвествующего сценария.

Порождение некого процесса это собственно создание дочернего процесса из родительского процесса. Последний затем продолжает своё выполнение асинхронно или ожидает пока этот дочерний процесс не завершится.

Библиотека multiprocessing позволяет порождать процессы такой последовательностью:

Давайте рассмотрим следующие шаги:

Без наличия такого метода join дочерний процесс не завершится и его потребуется уничтожать вручную.

В этом разделе мы таким образом увидели как можно создавать процесс запуская некий дочерний процесс. Такая функциональность именуется порождением процесса (spawning a process).

Библиотека Python multiprocessing делает возможным простое управление следующими тремя простыми шагами. Самый первый шаг состоит в определении самого процесса через метод класса multiprocessing, Process:

process = multiprocessing.Process(target=myFunc, args=(i,))
 	   

Этот метод Process имеет некий параметр подлежащей порождению функции, myFunc, а также все параметры внутри самой этой функции.

Следующие два шага необходимы для выполнения данного процесса и выхода из него:

process.start()
process.join()
 	   

Чтобы запустить необходимый процесс и отобразить его результаты, давайте откроем приглашение Командной строки, причём предпочтительно в том же самом каталоге, который содержит наш фал примера (spawning_processes.py) и затем наберём следующую команду:

> python spawning_processes.py
		

Для всех созданных процессов (их всего шесть) показывается получаемый вывод целевой функции. Помните, что это некий простейший счётчик от нуля до значения индекса установленного идентификатора процесса:

calling myFunc from process n°: 0
calling myFunc from process n°: 1
output from myFunc is :0
calling myFunc from process n°: 2
output from myFunc is :0
output from myFunc is :1
calling myFunc from process n°: 3
output from myFunc is :0
output from myFunc is :1
output from myFunc is :2
calling myFunc from process n°: 4
output from myFunc is :0
output from myFunc is :1
output from myFunc is :2
output from myFunc is :3
calling myFunc from process n°: 5
output from myFunc is :0
output from myFunc is :1
output from myFunc is :2
output from myFunc is :3
output from myFunc is :4
		

Это вновь напоминает нам о важности создания экземпляра необходимого объекта Process внутри самого главного раздела: это происходит по той причине, что создаваемый дочерний процесс импортирует сам файл сценария, который содержит необходимую функцию target. Затем, порождая соответствующий объект process внутри этого блока, мы предотвращаем некий бесконечный рекурсивный вызов такого порождения экземпляров.

Для задания самой функции target в каком- то ином сценарии применяется некий допустимый обходной путь, а именно, myFunc.py:

def myFunc(i):
    print ('calling myFunc from process n°: %s' %i)
    for j in range (0,i):
        print('output from myFunc is :%s' %j)
    return
 	   

Сама программа main, содержащая экземпляр головного процесса определяется в неком втором файле (target):

import multiprocessing
from myFunc import myFunc

if __name__ == '__main__':
    for i in range(6):
        process = multiprocessing.Process(target=myFunc, args=(i,))
        process.start()
        process.join()
 	   

Для запуска этого примера наберите следующую команду:

> python spawning_processes_names.py
		

Получаемый вывод будет тем же самым что и у нашего предыдущего примера.

Официальное руководство по этой библиотеке multiprocessing можно найти по ссылке.

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

В некотором месте вашего кода может быть критически важным знать какой именно процесс исполняется в настоящий момент. Для этой цели обсуждаемая нами библиотека multiprocessing предоставляет свой метод current_process(), который применяет значение атрибута name для определения того какой процесс исполняется в данный момент. В своём следующем разделе мы рассмотрим эту тему.

Давайте выполним такие шаги:

В нашей программе main все процессы создаются с применением одной и той же целевой функции, myFunc. Эта функция просто выводит на печать название своего процесса.

Для запуска нашего примера откройте приглашение Командной строки и наберите такую команду:

> python naming_processes.py
		

Получаемый вывод будет примерно таким:

Starting process name = myFunc process
Starting process name = Process-2

Exiting process name = Process-2
Exiting process name = myFunc process
		

Основным процессом Python выступает multiprocessing.process._MainProcess, в то время как дочерним процессом является multiprocessing.process.Process. Это можно запросто проверить набрав следующее:

>>> import multiprocessing
>>> multiprocessing.current_process().name
'MainProcess'
		

Дополнительные сведения по этой теме можно найти по ссылке.

Запуск в фоновом режиме является состоянием исполнения, которое типично для некоторых программ, которым не требуется присутствие определённого пользователя или его вмешательство и которое может быть одновременным с выполнением прочих программ (и, тем самым, он возможен лишь в многозадачных системах), что имеет результатом тот факт, что пользователь не осведомлён о ней. Программы фонового режима обычно выполняют длинные или потребляющие много времени задачи, такие как программы однорангового совместного использования файлов или дефрагментация файловых систем. Многие процессы ОС также выполняются в фоновом режиме.

В Windows программы в таком режиме (сканирующие антивирусы или обновляющие ОС) зачастую помещают некую иконку в системном лотке (system tray, та область на рабочем столе, которая следует за системными часами) чтобы сигнализировать о своей активности и приспосабливать поведение, которое снижает потребление ресурсов с тем, чтобы не оказывать влияния ни интерактивную деятельность самого пользователя, например, замедление или вызывание прерываний. В системах Unix или Unix- подобных, работающие в фоновом режиме процессы называются демонами. Воспользовавшись диспетчера задач можно выделить все исполняющиеся программы, включая те, которые работают в фоновом режиме.

Наш модуль multiprocessing позволяет - через свой демонический вариант - запускать процессы в фоновом режиме. В нашем следующем примере определяются два процесса:

В своём следующем примере мы реализуем некую целевую функцию, с названием foo, которая отображает цифры от 0 до 4, когда её дочерний процесс пребывает в фоновом режиме; в противном случае, она выводит на печать цифры от 5 до 9:

Заметим, что значение параметра daemon самого процесса определяет должен ли этот процесс запускаться в фоновом режиме или нет. Для исполнения данного примера наберите такую команду:

> python run_background_processes.py
		

Наш вывод очевидно выдаёт отчёт только о выводе NO_background_process:

Starting NO_background_process
---> 5

---> 6

---> 7

---> 8

---> 9
Exiting NO_background_process
		

Сам вывод изменяет соответствующую настройку значения параметра daemon для background_process на False:

background_process.daemon = False
		

Для исполнения этого примера наберите следующее:

C:\> python run_background_processes_no_daemons.py 
		

Получаемый вывод выдаёт отчёт о выполнении обоих процессов, и background_process, и NO_background_process:

Starting NO_background_process
Starting background_process
---> 5

---> 0
---> 6

---> 1
---> 7

---> 2
---> 8

---> 3
---> 9

---> 4

Exiting NO_background_process
Exiting background_process
		

Некий фрагмент кода для того как запускать некий сценарий Python в фоновом режиме в Linux можно найти по ссылке.

Не существует безупречного программного обеспечения и даже в самое наилучшее приложение вы можете вложить некую ошибку, которая приводит к блокировке данного приложения и именно по этой причине современные ОС имеют разработанными различные методы прекращения таких процессов приложений чтобы высвобождать системные ресурсы и позволять своему пользователю применять их для других операций настолько быстро, как только это возможно. Данный раздел покажет вам как уничтожать (kill) некий процесс в вашем приложении со множеством процессов.

Имеется возможность немедленного уничтожения процесса при помощи метода terminate. Кроме того мы воспользуемся методом is_alive для отслеживания того жив ли конкретный процесс или нет.

Для осуществления данного рецепта следуйте приводимым ниже шагам:

Наш образец кода состоит из некой целевой функции, foo(), задача которой состоит в выводе на экран печати самых первых 10 целых чисел. В нашей программе main этот процесс исполняется, а затем уничтожается инструкцией terminate. Этот процесс затем присоединяется и определяется ExitCode.

Для выполнения данного кода наберите такую команду:

> python killing_processes.py
		

После этого мы получаем следующий вывод:

Process before execution: <Process(Process-1, initial)> False
Process running: <Process(Process-1, started)> True
Process terminated: <Process(Process-1, started)> True
Process joined: <Process(Process-1, stopped[SIGTERM])> False
Process exit code: -15
		

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

В машине Linux некий процесс Python может быть идентифицирован, а затем уничтожен просто следуя такому руководству.

Модуль multiprocessing предоставляет доступ к функциям управления процессом. В данном разделе мы изучим как определять некий процесс в каком- то подклассе имеющегося класса multiprocessing.Process.

Для реализации некого индивидуального подкласса многопроцессности нам требуется выполнить следующие моменты:

После того как мы создали нужный нам новый подкласс Process, мы можем создать некий его экземпляр и затем запустить, вызвав соответствующий метод start, который, в свою очередь, вызывает установленный метод run.

Просто рассмотрим очень простой пример:

Каждый процесс подкласса представлен неким классом, который расширяет установленный класс Process и перекрывает его метод run(). Данный метод является отправной точкой Process:

class MyProcess (multiprocessing.Process):
    def run(self):
        print ('called run method in process: %s' %self.name)
        return
 	   

В своей программе main мы создаём некоторые объекты с типом Process(). Исполнение данного потока начинается после вызова метода start():

p = MyProcess()
p.start()
 	   

Наша команда join() просто обрабатывает сам процесс останова. Для выполнения этого сценария из приглашения Командной строки наберите такую команду:

> python process_in_subclass.py
		

Её вывод будет следующим:

called run method by MyProcess-1
called run method by MyProcess-2
called run method by MyProcess-3
called run method by MyProcess-4
called run method by MyProcess-5
called run method by MyProcess-6
called run method by MyProcess-7
called run method by MyProcess-8
called run method by MyProcess-9
called run method by MyProcess-10
		

В объектно ориентированном программировании некий подкласс является классом, который наследует все свойства из некого суперкласса, которыми выступают объекты и методы. Неким альтернативным названием подкласса является порождаемый класс (derived class). Наследование (inheritance) является специфическим термином, который указывает на тот процесс, коим его потомок или порождаемые классы наследуют свои свойства из родительского класса или суперклассов.

Вы можете представлять себе подкласс как определённую разновидность его суперкласса; на самом деле он может применять методы и/ или атрибуты, а также переопределять их путём перекрытия (overriding).

Дополнительные сведения по технологиям определения классов можно найти по ссылке.

Некая очередь является структурой данных с типом FIFO (First-In, First-Out, первый пришедший обслуживается первым). Неким примером из практики являются очереди на получение обслуживание, как производится оплата в супермаркете или ваша стрижка в парикмахерской. В идеале вы обслуживаетесь точно в том порядке, в котором вы были представлены. Именно так и работает очередь FIFO.

В данном разделе мы покажем вам как применять очередь для задачи производитель- потребитель, которая является классическим примером синхронизации процессов.

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

Основная задача производителя состоит в выработке данных для их непрерывного депонирования в имеющемся буфере. В то же самое время, существующий потребитель будет использовать произведённые данные, удаляя время от времени их из этого буфера. Основная задача состоит в гарантии того, что имеющийся производитель не вырабатывает новые данные когда буфер заполнен и что его потребитель не ищет данные когда буфер пуст. Основное решение состоит в том, что имеющийся производитель приостанавливает своё выполнение когда буфер заполнен.

Как только его потребитель возьмёт некий элемент из имеющегося буфера, наш производитель проснётся и начнёт снова наполнять этот буфер. Аналогично, наш потребитель приостановится когда буфер пуст. Как только его производитель выгрузит необходимые данные в имеющийся буфер, этот потребитель просыпается.

Это решение может быть реализовано посредством стратегий взаимодействия между процессами, совместной памятью или обменом сообщениями. Неверное решение может приводить к взаимной блокировке (deadlock), при которой оба процесса ожидают пробуждения.

import multiprocessing
import random
import time
 	   

Давайте выполним следующее:

Внутри своей программы main мы определяем необходимую очередь с помощью объекта multiprocessing.Queue. Затем он передаётся в качестве некого аргумента в процессы producer и consumer:

queue = multiprocessing.Queue()
process_producer = producer(queue)
process_consumer = consumer(queue)
 	   

В нашем классе producer метод queue.put применяется для добавления в конец общей очереди новых элементов:

self.queue.put(item)
 	   

В то же время в классе consumer его метод queue.get применяется для вытаскивания имеющихся элементов:

self.queue.get()
 	   

Выполните полученный код набрав следующую команду:

> python communicating_with_queue.py
		

Приводимый ниже вывод является отчётом о взаимодействии между нашими производителем и потребителем:

Process Producer : item 79 appended to queue producer-1
The size of queue is 1
Process Producer : item 50 appended to queue producer-1
The size of queue is 2
Process Consumer : item 79 popped from by consumer-2
Process Producer : item 33 appended to queue producer-1
The size of queue is 2
Process Producer : item 57 appended to queue producer-1
The size of queue is 3
Process Producer : item 227 appended to queue producer-1
Process Consumer : item 50 popped from by consumer-2
The size of queue is 3
Process Producer : item 98 appended to queue producer-1
The size of queue is 4
Process Producer : item 64 appended to queue producer-1
The size of queue is 5
Process Producer : item 182 appended to queue producer-1
Process Consumer : item 33 popped from by consumer-2
The size of queue is 5
Process Producer : item 206 appended to queue producer-1
The size of queue is 6
Process Producer : item 214 appended to queue producer-1
The size of queue is 7
Process Consumer : item 57 popped from by consumer-2
Process Consumer : item 227 popped from by consumer-2
Process Consumer : item 98 popped from by consumer-2
Process Consumer : item 64 popped from by consumer-2
Process Consumer : item 182 popped from by consumer-2
Process Consumer : item 206 popped from by consumer-2
Process Consumer : item 214 popped from by consumer-2
the queue is empty
		

Очередь обладает неким подклассом JoinableQueue. Он предоставляет такие методы:

Хорошее руководство относительно того как применять очереди доступно по ссылке.

Некий конвейер (pipe) выполняет следующее:

Рассматриваемая нами библиотека multiprocessing позволяет вам реализацию некой структуры данных конвейера при помощи своей функции multiprocessing.Pipe(duplex). Она возвращает некую пару объектов (conn1, conn2), которые представляют концы этого конвейера.

pipe_1 = multiprocessing.Pipe(True)
pipe_2 = multiprocessing.Pipe(True)
 	   

pipe_1 = multiprocessing.Pipe(True)
pipe_2 = multiprocessing.Pipe(True)
 	   

pipe_1[0].close()
pipe_2[0].close()
 	   

print (pipe_2[1].recv())
 	   

> python communicating_with_pipe.py
		

0
1
4
9
16
25
36
49
64
81