В этой статье мы узнаем, как добиться многопроцессорности с помощью Python и обсудим его передовые концепции.
Что такое многопроцессорность в Python?
Многопроцессорность в Python – это способность системы запускать несколько процессов параллельно. Проще говоря, многопроцессорность использует два или более ЦП в одной компьютерной системе. Этот метод также может распределять задачи между процессами.
Блоки обработки совместно используют основную память и периферийные устройства для одновременной обработки программ. Многопроцессорное приложение разбивается на более мелкие части и работает независимо. Каждый процесс назначается процессору операционной системой.
Python предоставляет встроенный пакет, называемый multiprocessing, который поддерживает процессы подкачки. Прежде чем работать с многопроцессорной обработкой, мы должны ознакомиться с объектом процесса.
Зачем нужна многопроцессорность?
Многопроцессорность необходима для выполнения множества задач в компьютерной системе. Предположим, компьютер не многопроцессорный, а однопроцессорного типа. Мы назначаем этой системе различные процессы одновременно.
Python Selenium #9 Запуск нескольких браузеров одновременно | Selenium Multiprocessing
Ему придется прервать предыдущую задачу и перейти к другой, чтобы все процессы продолжались. Принцип схож с тем, как повар работает один на кухне. Чтобы приготовить еду, он должен выполнять несколько задач, таких как нарезка, очистка, приготовление пищи, замешивание теста, выпечка и т. д.
Следовательно, многопроцессорность необходима для выполнения нескольких задач одновременно без прерывания. Это также позволяет легко отслеживать все задачи. Вот почему важна необходимость концепции многопроцессорности:
- Многопроцессорность можно представить как компьютер с более чем одним центральным процессором.
- Многоядерный процессор относится к одному вычислительному компоненту с двумя или более независимыми блоками.
В многопроцессорном режиме ЦП может назначать несколько задач, каждая из которых имеет свой собственный процессор.
Модуль многопроцессорности в Python
Python предоставляет модуль многопроцессорности для выполнения нескольких задач в одной системе. Он предлагает удобный и интуитивно понятный API для работы с многопроцессорной обработкой.
Давайте разберемся на простом примере множественной обработки.
from multiprocessing import Process def disp(): print (‘Hello !! Welcome to Python Tutorial’) if __name__ == ‘__main__’: p = Process(target=disp) p.start() p.join()
‘Hello !! Welcome to Python Tutorial’
В приведенном выше коде мы импортировали класс Process, а затем создали объект Process в функции disp(). Затем мы запустили процесс с помощью метода start() и завершили процесс с помощью метода join(). Мы также можем передавать аргументы в объявленную функцию, используя ключевые слова args.
Давайте разберемся в следующем примере многопроцессорной обработки с аргументами.
# Python multiprocessing example # importing the multiprocessing module import multiprocessing def cube(n): # This function will print the cube of the given number print(«The Cube is: <>».format(n * n * n)) def square(n): # This function will print the square of the given number print(«The Square is: <>».format(n * n)) if __name__ == «__main__»: # creating two processes process1 = multiprocessing.Process(target= square, args=(5, )) process2 = multiprocessing.Process(target= cube, args=(5, )) # Here we start the process 1 process1.start() # Here we start process 2 process2.start() # The join() method is used to wait for process 1 to complete process1.join() # It is used to wait for process 1 to complete process2.join() # Print if both processes are completed print(«Both processes are finished»)
The Cube is: 125 The Square is: 25 Both processes are finished
В приведенном выше примере мы создали две функции: функция cube() вычисляет куб данного числа, а функция square() вычисляет квадрат данного числа.
Как запустить 2 цикла одновременно или же Многопоточность в Python | #Python #Программирование #Гайд
Затем мы определили объект процесса класса Process, который имеет два аргумента. Первый аргумент – это target, который представляет функцию, которая должна быть выполнена, а второй аргумент – это args, который представляет аргумент, который должен быть передан внутри функции.
process1 = multiprocessing.Process(target= square, args=(5, )) process2 = multiprocessing.Process(target= cube, args=(5, ))
Как работать с многопоточностью в Python
Изучите основы многопоточности в Python с примерами, чтобы повысить производительность и отзывчивость вашего кода.
Алексей Кодов
Автор статьи
23 июня 2023 в 18:54
Многопоточность — это один из способов управления одновременным выполнением нескольких задач в программе. В Python это можно реализовать с помощью модуля threading . В этой статье мы разберемся, как использовать многопоточность в Python и рассмотрим примеры.
Создание потоков
Для создания потоков в Python используется класс Thread из модуля threading . Вот простой пример создания двух потоков, которые выводят сообщение о своем выполнении:
import threading def print_hello(): print(«Hello from thread», threading.current_thread().name) thread1 = threading.Thread(target=print_hello, name=»Thread-1″) thread2 = threading.Thread(target=print_hello, name=»Thread-2″) thread1.start() thread2.start() thread1.join() thread2.join() print(«All threads finished»)
Python-разработчик: новая работа через 9 месяцев
Получится, даже если у вас нет опыта в IT
В этом примере мы создаем два потока, задавая функцию print_hello в качестве их целевой функции. Затем мы запускаем потоки с помощью метода start() и ожидаем их завершения с помощью метода join() .
Использование блокировок
При работе с многопоточностью может возникнуть проблема, когда два или более потока пытаются одновременно получить доступ к общему ресурсу. В этом случае необходимо использовать блокировки, чтобы гарантировать, что только один поток имеет доступ к ресурсу в определенный момент времени.
Пример использования блокировок:
import threading counter = 0 lock = threading.Lock() def increment_counter(): global counter with lock: temp = counter counter = temp + 1 print(«Thread», threading.current_thread().name, «incremented counter to», counter) threads = [] for i in range(10): thread = threading.Thread(target=increment_counter, name=f»Thread-«) thread.start() threads.append(thread) for thread in threads: thread.join() print(«Counter value:», counter)
В этом примере потоки инкрементируют общий счетчик, используя блокировку для обеспечения безопасности доступа к общему ресурсу.
Обратите внимание, что блокировки могут привести к снижению производительности, если они используются часто или неправильно. Поэтому важно выбирать правильные механизмы синхронизации для вашего кода.
Заключение
В этой статье мы рассмотрели основы работы с многопоточностью в Python, включая создание потоков и использование блокировок. Многопоточность может быть полезным инструментом для улучшения производительности и отзывчивости вашего кода, но также требует особого внимания при работе с общими ресурсами и синхронизации.
Удачи вам в изучении многопоточности в Python! Если вы хотите узнать больше, рекомендуем обратиться к онлайн школе, которая учит специалистов в сфере «Python-разработка». Не забудьте использовать наш спец.тег
Источник: sky.pro
Учимся писать многопоточные и многопроцессные приложения на Python
Эта статья не для матёрых укротителей Python’а, для которых распутать этот клубок змей — детская забава, а скорее поверхностный обзор многопоточных возможностей для недавно подсевших на питон.
К сожалению по теме многопоточности в Python не так уж много материала на русском языке, а питонеры, которые ничего не слышали, например, про GIL, мне стали попадаться с завидной регулярностью. В этой статье я постараюсь описать самые основные возможности многопоточного питона, расскажу что же такое GIL и как с ним (или без него) жить и многое другое.
Python — очаровательный язык программирования. В нем прекрасно сочетается множество парадигм программирования. Большинство задач, с которыми может встретиться программист, решаются здесь легко, элегантно и лаконично. Но для всех этих задач зачастую достаточно однопоточного решения, а однопоточные программы обычно предсказуемы и легко поддаются отладке. Чего не скажешь о многопоточных и многопроцессных программах.
Многопоточные приложения
В Python есть модуль threading, и в нем есть все, что нужно для многопоточного программирования: тут есть и различного вида локи, и семафор, и механизм событий. Один словом — все, что нужно для подавляющего большинства многопоточных программ. Причем пользоваться всем этим инструментарием достаточно просто. Рассмотрим пример программы, которая запускает 2 потока. Один поток пишет десять “0”, другой — десять “1”, причем строго по-очереди.
import threading def writer(x, event_for_wait, event_for_set): for i in xrange(10): event_for_wait.wait() # wait for event event_for_wait.clear() # clean event for future print x event_for_set.set() # set event for neighbor thread # init events e1 = threading.Event() e2 = threading.Event() # init threads t1 = threading.Thread(target=writer, args=(0, e1, e2)) t2 = threading.Thread(target=writer, args=(1, e2, e1)) # start threads t1.start() t2.start() e1.set() # initiate the first event # join threads to the main thread t1.join() t2.join()
Никакой магии и voodoo-кода. Код четкий и последовательный.
Причем, как можно заметить, мы создали поток из функции. Для небольших задач это очень удобно. Этот код еще и достаточно гибкий. Допустим у нас появился 3-й процесс, который пишет “2”, тогда код будет выглядеть так:
import threading def writer(x, event_for_wait, event_for_set): for i in xrange(10): event_for_wait.wait() # wait for event event_for_wait.clear() # clean event for future print x event_for_set.set() # set event for neighbor thread # init events e1 = threading.Event() e2 = threading.Event() e3 = threading.Event() # init threads t1 = threading.Thread(target=writer, args=(0, e1, e2)) t2 = threading.Thread(target=writer, args=(1, e2, e3)) t3 = threading.Thread(target=writer, args=(2, e3, e1)) # start threads t1.start() t2.start() t3.start() e1.set() # initiate the first event # join threads to the main thread t1.join() t2.join() t3.join()