Автор оригинала: Pankaj Kumar.
В нашем предыдущем уроке мы узнали о примере Python CSV. В этом руководстве мы собираемся изучать многопроцессор Python с примерами.
Мультипрослессинг Python
Параллельная обработка получает больше внимания. Если вы все еще не знаете о параллельной обработке, учитесь на Википедия Отказ
Когда производители ЦП начнут добавлять все больше и больше ядер к своим процессорам, создание параллельного кода является отличным способом повышения производительности. Python представил Многопроцессор Модуль, чтобы написать параллельный код.
Чтобы понять основную мотивацию этого модуля, мы должны знать некоторые основы о параллельном программировании. Прочитав эту статью, мы надеемся, что вы сможете собрать некоторые знания по этой теме.
Процесс многопроцессора Python, очередь и замки
Существует множество классов в многопроцессорном модульном модуле Python для построения параллельной программы. Среди них три основных классов Процесс , Очередь и Замок Отказ Эти классы помогут вам построить параллельную программу.
Но перед тем, как описать о них, давайте начать эту тему простым кодом. Чтобы сделать параллельную программу полезной, вы должны знать, сколько ядер в вашем ПК. Модуль многопроцессора Python позволяет вам знать это. Следующий простой код будет распечатать количество ядер на вашем компьютере.
import multiprocessing
print("Number of cpu : ", multiprocessing.cpu_count())
Следующий вывод может варьироваться для вашего ПК. Для меня количество сердечников 8.
MultiPressing Phyton MultiPressing Process Class
Мультипроизводство Python Процесс Класс – это абстракция, которая устанавливает другой процесс Python, предоставляет ему код и способ для родительского приложения для управления выполнением.
Есть две важные функции, которые принадлежат к классу процесса – Start () и Присоединяйтесь () функция.
Сначала нам нужно написать функцию, которая будет работать по процессу. Затем нам нужно создать объект процесса.
Если мы создадим объект процесса, ничего не произойдет, пока мы не скажем, чтобы начать обработку через Start () функция. Затем процесс будет работать и вернет свой результат. После этого мы сообщим процессу завершить через Присоединяйтесь () функция.
Без Присоединяйтесь () Функциональный вызов, процесс останется холостым и не заканчивается.
Поэтому, если вы создаете много процессов и не прекращаете их, вы можете столкнуться с дефицитом ресурсов. Тогда вам может понадобиться убить их вручную.
Одна важная вещь, если вы хотите пройти любой аргумент через процесс, который вам нужно использовать args Ключевое слово аргумент. Следующий код будет полезен для понимания использования класса процесса.
from multiprocessing import Process
def print_func(continent='Asia'):
print('The name of continent is : ', continent)
if __name__ == "__main__": # confirms that the code is under main function
names = ['America', 'Europe', 'Africa']
procs = []
proc = Process(target=print_func) # instantiating without any argument
procs.append(proc)
proc.start()
# instantiating process with arguments
for name in names:
# print(name)
proc = Process(target=print_func, args=(name,))
procs.append(proc)
proc.start()
# complete the processes
for proc in procs:
proc.join()
Выход следующего кода будет:
Многопроцессорная очередь очереди Python
У вас есть базовые знания о компьютерной структуре данных, вы, вероятно, знаете о очереди.
Многопроцессорные модули Python обеспечивают Очередь класс, который именно Первый вначале структура данных. Они могут хранить любой объект Pyry Python (хотя простые из них лучше) и чрезвычайно полезны для совместного использования данных между процессами.
Очески специально полезны при прохождении в качестве параметра к процессу «Целевая функция» для включения процесса для потребления данных. Используя поставить () Функция мы можем вставить данные в очередь и использовать Получить () Мы можем получить предметы из очередей. Смотрите следующий код для быстрого примера.
from multiprocessing import Queue
colors = ['red', 'green', 'blue', 'black']
cnt = 1
# instantiating a queue object
queue = Queue()
print('pushing items to queue:')
for color in colors:
print('item no: ', cnt, ' ', color)
queue.put(color)
cnt += 1
print('\npopping items from queue:')
cnt = 0
while not queue.empty():
print('item no: ', cnt, ' ', queue.get())
cnt += 1
Многопроцессорный замок Python
Задача класса блокировки довольно проста. Он позволяет коду претендовать за блокировку, так что ни один другой процесс не может выполнить аналогичный код, пока не будет выпущен замок. Таким образом, задача класса блокировки в основном два. Один из них должен претендовать за замку и другое – отпустить замок. Претендовать за блокировку, приобретать () Функция используется и отпустить замок Выпуск () Функция используется.
Пример многопроцессора Python
В этом примере многопроцессора Python мы объединим все наши знания вместе.
Предположим, у нас есть некоторые задачи для достижения. Чтобы выполнить эту задачу, мы будем использовать несколько процессов. Итак, мы будем поддерживать две очередь. Один будет содержать задачи, а другая будет содержать журнал выполненной задачи.
Затем мы создали процессы, чтобы завершить задачу. Обратите внимание, что класс очереди Python уже синхронизирован. Это означает, что нам не нужно использовать класс блокировки, чтобы заблокировать несколько процессов для доступа к тому же объекту очереди. Вот почему нам не нужно использовать класс блокировки в этом случае.
Ниже приведена реализация, в которой мы добавляем задачи в очередь, то создавая процессы и запускайте их, затем используя Присоединяйтесь () завершить процессы. Наконец мы печатаем журнал от второй очереди.
from multiprocessing import Lock, Process, Queue, current_process
import time
import queue # imported for using queue.Empty exception
def do_job(tasks_to_accomplish, tasks_that_are_done):
while True:
try:
'''
try to get task from the queue. get_nowait() function will
raise queue.Empty exception if the queue is empty.
queue(False) function would do the same task also.
'''
task = tasks_to_accomplish.get_nowait()
except queue.Empty:
break
else:
'''
if no exception has been raised, add the task completion
message to task_that_are_done queue
'''
print(task)
tasks_that_are_done.put(task + ' is done by ' + current_process().name)
time.sleep(.5)
return True
def main():
number_of_task = 10
number_of_processes = 4
tasks_to_accomplish = Queue()
tasks_that_are_done = Queue()
processes = []
for i in range(number_of_task):
tasks_to_accomplish.put("Task no " + str(i))
# creating processes
for w in range(number_of_processes):
p = Process(target=do_job, args=(tasks_to_accomplish, tasks_that_are_done))
processes.append(p)
p.start()
# completing process
for p in processes:
p.join()
# print the output
while not tasks_that_are_done.empty():
print(tasks_that_are_done.get())
return True
if __name__ == '__main__':
main()
В зависимости от количества задач код займет некоторое время, чтобы показать вам вывод. Выход следующего кода от времени будет варьироваться от времени.
Мультипроцессорный пул Python
Мультипроцентный пул Python может использоваться для параллельного выполнения функции в нескольких входных значениях, распространяющих входные данные в процессах (параллельность данных). Ниже приведен простой пример музыкального бассейна Python.
from multiprocessing import Pool
import time
work = (["A", 5], ["B", 2], ["C", 1], ["D", 3])
def work_log(work_data):
print(" Process %s waiting %s seconds" % (work_data[0], work_data[1]))
time.sleep(int(work_data[1]))
print(" Process %s Finished." % work_data[0])
def pool_handler():
p = Pool(2)
p.map(work_log, work)
if __name__ == '__main__':
pool_handler()
Ниже приведены изображение показывает выход вышеуказанной программы. Обратите внимание, что размер пула 2, поэтому два исполнения Work_Log Функция происходит параллельно. Когда одна из обработки функций заканчивается, она выбирает следующий аргумент и так далее.
Итак, это все для многопроцессорного модуля Python.
Ссылка: Официальная документация