Python multiprocessing - это мощный инструмент, который может значительно ускорить выполнение Python-программ, требующих высокой вычислительной мощности. В этом лабе вы узнаете о Python multiprocessing и о том, как использовать его для параллельного запуска процессов. Мы начнем с простых примеров и постепенно перейдем к более сложным.
Первым шагом в изучении многопроцессорности в Python является создание простой программы, которая демонстрирует, как это работает. В этой программе мы создадим функцию, которая принимает один аргумент и возвращает квадрат этого числа. Затем мы используем многопроцессорность для запуска этой функции на нескольких процессах.
Пожалуйста, завершите square.py.
import multiprocessing
def square(x):
return x * x
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=4)
results = pool.map(square, range(10))
print(results)Этот код создает пул из четырех процессов и использует функцию map(), чтобы применить функцию square() к каждому из чисел в диапазоне от 0 до 9. Затем результаты выводятся в консоль.
Теперь, когда вы понимаете, как работает многопроцессорность в Python, мы можем перейти к более сложному примеру. В этом примере мы будем использовать многопроцессорность для ускорения обработки большого списка чисел.
Пожалуйста, завершите complex_square.py.
import multiprocessing
def square(x):
return x * x
if __name__ == '__main__':
with multiprocessing.Pool(processes=4) as pool:
results = pool.map(square, range(1000000))
print(results[:10])Этот код создает пул из четырех процессов и использует функцию map(), чтобы применить функцию square() к каждому из чисел в диапазоне от 0 до 999999. Строка with используется для обеспечения правильного закрытия пула процессов при завершении обработки. Затем выводятся первые десять результатов в консоль.
В некоторых случаях при использовании многопроцессорности в Python может потребоваться обмен данными между процессами. В этом примере мы будем использовать функцию multiprocessing.Queue() для создания общих очередей между процессами.
Пожалуйста, завершите multiprocessing_queue.py.
import multiprocessing
def producer(queue):
for i in range(10):
queue.put(i)
def consumer(queue):
while True:
item = queue.get()
if item is None:
break
print(item)
if __name__ == '__main__':
queue = multiprocessing.Queue()
process_producer = multiprocessing.Process(target=producer, args=(queue,))
process_consumer = multiprocessing.Process(target=consumer, args=(queue,))
process_producer.start()
process_consumer.start()
process_producer.join()
queue.put(None)
process_consumer.join()В этом коде с помощью функции multiprocessing.Queue() создается общая очередь queue. Затем создаются два процесса, каждый из которых вызывает функцию producer() и consumer(). Функция producer() помещает числа от 0 до 9 в очередь, а функция consumer() извлекает каждый элемент из очереди и выводит его в консоль.
Кроме map(), класс multiprocessing.Pool() предоставляет другой метод для параллельного запуска процессов, называемый apply_async(). Этот метод позволяет вам отправить вызов функции в пул процессов и немедленно продолжить выполнение, не ожидая результата. Вместо этого вы можете использовать обратный вызов (callback-функцию), чтобы получить результат вызова функции, когда он будет готов.
Пожалуйста, завершите slow_square.py.
import multiprocessing
import time
def slow_square(x):
time.sleep(1)
return x * x
def callback(result):
print(result)
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=4)
results = [pool.apply_async(slow_square, (x,), callback=callback) for x in range(10)]
for result in results:
result.wait()
print("All tasks completed.")В этом примере мы определяем функцию slow_square(), которая принимает число x, ждет одну секунду и затем возвращает квадрат x. Мы также определяем обратную вызов функцию callback(), которая просто выводит результат, когда он доступен.
Затем мы создаем пул из четырех процессов и используем apply_async(), чтобы отправить вызов функции в пул для каждого числа в диапазоне от 0 до 9. Мы передаем функцию slow_square() и аргумент x с использованием параметра args, а также указываем обратную вызов функцию, которая должна быть вызвана, когда результат будет готов.
Затем мы перебираем список результатов и вызываем result.wait(), чтобы заблокировать главный поток, пока результат не будет готов. Наконец, мы выводим сообщение, указывающее, что все задачи завершены.
В этом практическом занятии вы узнали, как использовать многопроцессорность в Python для параллельного запуска процессов. Вы начали с простой программы, которая демонстрировала, как работает многопроцессорность, а затем перешли к более сложным примерам, где использовалась многопроцессорность для ускорения обработки, разделения памяти между процессами и выполнения асинхронных задач с использованием apply_async(). В конце этого практического занятия вы должны хорошо понять, как использовать многопроцессорность в своих собственных программах на Python, чтобы достичь большей вычислительной мощности и эффективности, а также как обмениваться данными между процессами при необходимости.
