Класс Process() модуля multiprocessing в Python.

Создание отдельного процесса, запуск задачи и получение результата выполнения.

Синтаксис:

Параметры:

Конструктор всегда следует вызывать с ключевыми аргументами.

• group=None — не используется модулем,
• target=None — вызываемый объект (функция),
• name=None — имя процесса,
• args=() — аргументы для target ,
• kwargs=<> — ключевые аргументы для target ,
• daemon=None — флаг для демонизации процесса.

Возвращаемое значение:

Описание:

Класс Process() модуля multiprocessing запускает вызываемый объект target на исполнение, который будет выполняется в отдельном процессе/ядре процессора.

Есть два способа запустить какое либо действие:

• Передать вызываемый объект (функцию) target в конструктор.
• Переопределить метод Process.run() в подклассе.

Внимание! Никакие другие методы не должны переопределяться в подклассе (кроме конструктора). Другими словами, можно переопределять только методы __init__() и Process.run() этого класса.

Объект Process имеет эквиваленты всех методов объекта Thread() .

Аргумент group всегда должна быть None ; он существует исключительно для совместимости с классом threading.Thread() .

Аргумент target — это вызываемый объект, который будет вызываться методом Process.run() . По умолчанию это None , что означает, что ничего не вызывается. По умолчанию в вызываемый объект target не передаются его аргументы.

Аргумент name — это имя процесса, подробнее смотрите атрибут Process.name .

Аргумент args — это кортеж аргументов для целевого вызова target . Аргумент kwargs — это словарь ключевых аргументов для целевого вызова target .

Если предоставлен ключевой аргумент daemon , то он устанавливает флаг демона процесса значение True или False . Если daemon=None (по умолчанию), этот флаг будет унаследован от процесса создателя.

Если подкласс переопределяет конструктор класса multiprocessing.Process() , то необходимо вызывать конструктор базового класса Process.__init__() , прежде чем делать что-либо еще с процессом.

Обратите внимание, что методы Process.start() , Process.join() , Process.is_alive() , Process.terminate() и Process.exitcode должны вызываться только процессом, создавшим этот объект процесса.

Методы объекта Process .

Объекты Process представляют собой действия, которые выполняются в отдельном процессе.

Process.run() :

Метод Process.run() представляет активность процесса.

Можно переопределить этот метод в своем подклассе. Стандартный метод Process.run() вызывает вызываемый объект, переданный конструктору в качестве целевого аргумента target , с позиционными и ключевыми аргументами, взятыми из аргументов args и kwargs соответственно.

Метод Thread.run() можно переопределить в пользовательском подклассе. Например:

Process.start() :

Метод Process.start() запускает экземпляр Process в отдельном процессе/ядре процессора.

Этот метод должен быть вызван не более одного раза для каждого объекта процесса. Он организует вызов метода Process.run() объекта в отдельном процессе/ядре процессора.

Дополнительно, смотрите описание этого метода у объекта Thread , примеры кода аналогичны.

Process.join([timeout]) :

Метод Process.join() ждет, пока не завершится процесс.

Если необязательный аргумент timeout=None (по умолчанию), то процесс, из которого вызван этот метод, блокируется до тех пор, пока не завершится процесс, у которого вызван этот метод. Проще говоря, если вызвать метод Process.join() для создаваемых процессов из основного процесса программы, то дальнейшее выполнение программы будет заблокировано, пока созданные процессы не завершаться.

Если тайм-аут timeout является положительным числом, то процесс блокируется не более чем на величину секунд, указанную в timeout . Обратите внимание, что метод возвращает None , если его процесс завершается или если время ожидания метода истекает. Проверьте код выхода процесса Process.exitcode , чтобы определить, завершился ли он.

К процессу можно присоединяться много раз.

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

Дополнительно, смотрите описание этого метода у объекта Thread , примеры кода аналогичны.

Process.name :

Атрибут Process.name это имя процесса и представляет собой строку, которая используется только для идентификации. У имени нет семантики.

Несколько процессов могут иметь одно и то же имя (можно присваивать).

Начальное имя задается конструктором класса. Если в конструктор не передан аргумент name , то имена порожденных процессов будет выглядеть как «Process-N1:N2. Nk», где каждый Nk является N-м потомком своего родителя.

Дополнительно, смотрите описание этого метода у объекта Thread , примеры кода аналогичны.

Process.is_alive() :

Метод Process.is_alive() проверяет, является ли процесс живым.

Грубо говоря, объект процесса является живым с момента вызова метода Process.start() и до завершения порожденного дочернего процесса.

Process.daemon :

Атрибут Process.daemon флаг демона процесса, логическое значение. Этот атрибут должен быть установлен перед вызовом метода Process.start() .

Начальное значение наследуется от процесса создателя.

Когда процесс завершается, он пытается завершить все свои демонические дочерние процессы.

Обратите внимание, что демоническому процессу не разрешается создавать дочерние процессы. Так как если демонический процесс будет прерван выходом из родительского процесса, то демонический процесс оставил бы свои дочерние процессы «сиротами«. Кроме того, это не демоны или службы Unix, это обычные процессы, которые будут завершены (но не присоединены), если завершились не-демонические процессы.

Process.pid :

Атрибут Process.pid возвращает идентификатор процесса. До того, как процесс будет порожден, это будет None .

Process.exitcode :

Атрибут Process.exitcode возвращает код выхода порожденного процесса. Значение будет None , если процесс еще не завершен.

Отрицательное значение -N указывает, что дочерний элемент был прерван сигналом N .

Process.authkey :

Атрибут Process.authkey ключ аутентификации процесса, представляет из себя байтовую строку.

При инициализации модуля multiprocessing , основному процессу присваивается случайная строка с помощью os.urandom() .

Когда создается объект процесса, то он наследует ключ аутентификации своего родительского процесса, хотя это может быть изменено путем установки атрибута authkey в другую байтовую строку.

Process.sentinel :

Атрибут Process.sentinel числовой дескриптор системного объекта, который станет «готовым» по завершении процесса.

Можно использовать это значение, если необходимо дождаться нескольких событий одновременно, используя multiprocessing.connection.wait() . Вообще это проще сделать вызвав метод Process.join() у каждого из создаваемых процессов, результатов которых надо дождаться.

В Windows это дескриптор ОС, который можно использовать с семейством вызовов API WaitForSingleObject и WaitForMultipleObjects . В Unix это файловый дескриптор, который можно использовать с примитивами из модуля select .

Process.terminate() :

Метод Process.terminate() завершает процесс. В Unix это делается с помощью сигнала SIGTERM , в Windows используется TerminateProcess() .

Обратите внимание, что обработчики выхода, предложения tru/finally и т. д. не будут выполняться.

Получение сведений о процессах, модуль multiprocessing в Python.

Функции модуля, для получения сведений о запущенных процессах.

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

Содержание:

• multiprocessing.active_children() список всех живых дочерних процессов,
• multiprocessing.cpu_count() количество имеющихся ядер процессора,
• multiprocessing.current_process() возвращает объект Process текущего процесса,
• multiprocessing.parent_process() возвращает объект Process родительского процесса,
• multiprocessing.freeze_support() поддержка замороженных процессов,
• multiprocessing.get_all_start_methods() список поддерживаемых методов запуска,
• multiprocessing.get_context() возвращает объект контекста,
• multiprocessing.get_start_method() возвращает имя метода запуска,
• multiprocessing.set_executable() задает путь интерпретатора Python,
• multiprocessing.set_start_method() устанавливает метод запуска дочерних процессов.

multiprocessing.active_children() :

Функция multiprocessing.active_children() возвращает список всех живых дочерних элементов текущего процесса.

Вызов функции этого имеет побочный эффект — «присоединение» ( .join ) к уже завершенным процессам.

multiprocessing.cpu_count() :

Функция multiprocessing.cpu_count() возвращает количество имеющихся ядер процессора на машине/сервере.

Возвращаемое число не эквивалентно числу ядер, которые может использовать текущий процесс, т.к. некоторые ядра могут быть заняты другими процессами. Количество ядер, которое может использовать текущий процесс можно получить при помощи вызова len( os.sched_getaffinity(0) .)

Вызов функции multiprocessing.cpu_count() может вызывать исключение NotImplementedError .

Смотрите также функцию os.cpu_count() .

multiprocessing.current_process() :

Функция multiprocessing.current_process() возвращает объект Process , соответствующий текущему процессу.

multiprocessing.parent_process() :

Функция multiprocessing.parent_process() возвращает объект Process , соответствующий родительскому процессу multiprocessing.current_process() .

Для основного процесса multiprocessing.parent_process() возвращает None .

Новое в Python 3.8.

multiprocessing.freeze_support() :

Функция multiprocessing.freeze_support() добавляет поддержку, если программа использующая модуль multiprocessing была заморожена для создания исполняемого файла Windows. Протестирована с модулями py2exe , PyInstaller и cx_Freeze .

Вызов функции нужно добавлять сразу после строки if __name__ == ‘__main__’ основного модуля. Например:

Если строка freeze_support() опущена, то попытка запустить замороженный исполняемый файл вызовет RuntimeError .

Вызов multiprocessing.freeze_support() не имеет никакого эффекта, кроме как в Windows. Кроме того, если модуль нормально запускается интерпретатором Python в Windows (программа не была заморожена), то freeze_support() не нужна.

multiprocessing.get_all_start_methods() :

Функция multiprocessing.get_all_start_methods() возвращает список поддерживаемых методов запуска, первый из которых используется по умолчанию.

Возможные методы запуска: fork , spawn и forkserver (смотрите их описание в обзорном материале к модулю multiprocessing ). В Windows доступен только spawn . В Unix всегда поддерживаются fork и spawn , по умолчанию используется — fork .

multiprocessing.get_context(method=None) :

Функция multiprocessing.get_context() возвращает объект контекста, имеющий тот же API, что и сам модуль multiprocessing .

Если аргумент method=None , то возвращается контекст по умолчанию. В противном случае метод запуска процессов должен быть fork , spawn или forkserver .

Если указанный метод запуска недоступен, то возникает исключение ValueError .

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

Обратите внимание, что объекты, относящиеся к одному контексту, могут быть несовместимы с процессами для другого контекста. В частности, блокировки, созданные с использованием контекста fork , не могут быть переданы процессам, запущенным с помощью методов запуска spawn или forkserver .

multiprocessing.get_start_method(allow_none=False) :

Функция multiprocessing.get_start_method() возвращает имя метода запуска, используемого для запуска процессов.

Если метод запуска не был исправлен и аргумент allow_none имеет значение False , то метод запуска фиксируется по умолчанию и возвращается его имя.

Если метод запуска не был исправлен и аргумент allow_none имеет значение True , то возвращается None .

Возвращаемое значение может быть fork , spawn , forkserver или None . Значением по умолчанию в Unix является метод запуска процессов fork , а в Windows по умолчанию — spawn .

multiprocessing.set_executable() :

Функция multiprocessing.set_executable() задает путь интерпретатора Python для использования при запуске дочернего процесса. По умолчанию используется sys.executable .

Для встраиваемых программ, вероятно, потребуется что-то вроде:

прежде чем они смогут создавать дочерние процессы.

multiprocessing.set_start_method(method) :

Функция multiprocessing.set_start_method() устанавливает метод, который следует использовать для запуска дочерних процессов. Метод запуска процессов может быть fork , spawn или forkserver .

Обратите внимание, что функция должна вызываться не более одного раза и должна быть защищена внутри блока if __name__ == ‘__main__’ основного модуля.

Python windows get process

A Process is a program that is being executed (processed). A process may not have to be one run explicitly by the user, it could be a system process spawned by the operating system. Any applications that execute on an operating system firstly creates a process of its own in order to execute. In a typical OS installation, most processes are os services and background applications, that are run to maintain the operating system, software and hardware.
In this article, we will take a look at different ways of obtaining the list of running processes of a Windows OS, through Python. Firstly, we would describe a python method in order to achieve the result and then would look at a command found in the Windows Command Processor for the same.
Method 1:
We would be using the wmi library for getting the list of running processes on Windows OS. In order the install the module, execute the following command in the command interpreter of your operating system:-

COde:

Python3

Output:

Explanation:
Firstly, we initialize the WMI() function of wmi library. This allows us to use the functions found inside it such as WMI.Win32_Service, WMI.Win32_Process, WMI.Win32_Printjob which are designed to perform different tasks. We would be using the WMI.Win32_Process function in order to get the list of running processes on the system. Then we called the function WMI.Win32_Process() to get the running processes, iterated through each process and stored in variable process. Then we obtained the ProcessID (pid) and ProcessName (name) of the process using the associated attributes. We used F-strings for the output in order to add padding to the output to align it properly.

Method 2:
In this method, we would be using a command found inside the Windows Command Processor (cmd.exe) under the name WMIC ( Windows Management Instrumentation Command line) in order to get the desired result. WMIC is a commandline utility that allows users to performs Windows Management Instrumentation (WMI) operations with a command prompt. For the purpose of getting running processes, we would be executing the command:

Code:

Python3

Output:

Note: It is not mandatory to use the os library for the purpose. The user could pick any other alternatives (Subprocess, shutil etc) which allows for commandline command execution.
Explanation:
We used the function popen() found inside the os module, in order to execute the command in the command processor. Then we passed the output of the above command to read() in order to get data in readable form out of os._wrap_close object. In the end, we displayed the output.

Method 3:

We will use the subprocess module to interact with cmd and to retrieve information into your python ide. we can read the cmd command through the subprocess module.

Let’s see this logic, if we run this wmic process list brief code into our terminal then we got like this: