Что такое Mutithreading в Python и как этого добиться?



Узнайте, что такое многозадачность в Python. В нем также объясняется многопоточность, как создавать потоки без создания класса, расширяя класс Thread и не расширяя его.

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

создать копию объекта java

Вот краткое описание всех специальностей, рассмотренных в этой статье:





Что многозадачность в Python?
Что такое нить?
Что такое многопоточность в Python?
Когда использовать многопоточность в Python?
Как добиться многопоточности в Python?
Как создавать потоки в Python?

Преимущества использования многопоточности в Python



Для начала давайте сначала попробуем понять многозадачность, прежде чем мы начнем изучать многопоточность в Python.

Что такое многозадачность в Python?

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

В ОС есть два типа многозадачности:



  • На основе процесса
  • На основе потоков

В этой статье вы узнаете о На основе потоков многозадачность или Многопоточность .

Что такое нить?

потоки-многопоточность в python-edurekaПоток в основном независимый поток исполнения. Один процесс может состоять из нескольких потоков. Каждый поток в программе выполняет определенную задачу. Например, когда вы играете в игру, скажите FIFA на вашем ПК, игра в целом представляет собой единый процесс , но он состоит из нескольких потоков, отвечающих за воспроизведение музыки, получение данных от пользователя, синхронный запуск оппонента и т. д. Все это отдельные потоки, отвечающие за выполнение этих различных задач в одной программе.

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

Итак, я надеюсь, что вы ясно поняли, что такое поток. Продолжая, давайте посмотрим, что такое многопоточность в Python.

Когда использовать многопоточность в Python?

Многопоточность очень полезна для экономии времени и повышения производительности, но не может применяться везде.
В предыдущем примере с FIFA музыкальный поток не зависит от потока, который принимает ваш ввод, а поток, который принимает ваш ввод, не зависит от потока, который запускает ваш оппонент. Эти потоки выполняются независимо, потому что они не зависят друг от друга.

Следовательно, многопоточность можно использовать только тогда, когда не существует зависимости между отдельными потоками.

В этой статье также показано, как добиться многопоточности в Python.

Как добиться многопоточности в Python?

Многопоточность в Python может быть достигнута путем импорта заправка модуль.

Перед импортом этого модуля вам необходимо установить его. Чтобы установить это в вашей среде anaconda, выполните следующую команду в командной строке anaconda:

conda install -c conda-forge tbb

После его успешной установки вы можете использовать любую из следующих команд для импорта модуля потоковой передачи:

импорт потоков из импорта *

Теперь, когда у вас установлен модуль потоковой передачи, давайте продолжим и займемся многопоточностью в Python.

Как создавать потоки в Python?


Потоки в Python можно создавать тремя способами:

  1. Без создания класса
  2. Расширяя класс Thread
  3. Без расширения класса Thread

Без создания класса

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

mysql_fetch_array

Пример:

from threading import * print (current_thread (). getName ()) def mt (): print ('Дочерний поток') child = Thread (target = mt) child.start () print ('Имя исполняемого потока:', current_thread ( ) .getName ())

Вывод:

MainThread Дочерний поток Имя исполняющего потока: MainThread

Приведенный выше вывод показывает, что первый присутствующий поток является основным потоком. Затем этот основной поток создает дочерний поток, который выполняет функцию, а затем последний оператор печати снова выполняется основным потоком.

Теперь давайте продвинемся вперед и посмотрим, как реализовать многопоточность в python, расширив класс Thread.

Расширяя класс Thread:

Когда дочерний класс создается путем расширения класса Thread, дочерний класс представляет, что новый поток выполняет некоторую задачу. При расширении класса Thread дочерний класс может переопределить только два метода, то есть метод __init __ () и метод run (). Никакой другой метод, кроме этих двух, нельзя переопределить.

Вот пример того, как расширить класс Thread для создания потока:

Пример:

import threading импортировать время класса migread (threading.Thread): def run (self): for x in range (7): print ('Hi from child') a = migread () a.start () a.join () print ('До свидания', current_thread (). GetName ())

Вывод:
Привет от ребенка
Привет от ребенка
Привет от ребенка
Привет от ребенка
Привет от ребенка
Привет от ребенка
Привет от ребенка
Пока от MainThread

В приведенном выше примере показано, что класс myclass наследует класс Thread и дочерний класс, то есть myclass переопределяет метод запуска. По умолчанию первым параметром любой функции класса должен быть self, который является указателем на текущий объект. Выходные данные показывают, что дочерний поток выполняет метод run (), а основной поток ожидает завершения выполнения дочерних потоков. Это из-за функции join (), которая заставляет основной поток ждать завершения дочернего процесса.

Этот метод создания потоков является наиболее предпочтительным, поскольку он является стандартным. Но если вы хотите создавать потоки без наследования или расширения класса Thread, вы можете сделать это следующим образом.

Без расширения класса Thread

Чтобы создать поток без расширения класса Thread, вы можете сделать следующее:
Пример:

from threading import * class ex: def myfunc (self): #self необходимо в качестве первого параметра в классе func для x в диапазоне (7): print ('Child') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () print ('готово')

Вывод:

Ребенок
Ребенок
Ребенок
Ребенок
Ребенок
Ребенок
Ребенок
сделанный

Дочерний поток выполняет myfunc, после чего основной поток выполняет последний оператор печати.

Преимущества использования резьбы

Многопоточность имеет множество преимуществ, некоторые из которых следующие:

  • Лучшее использование ресурсов
  • Упрощает код
  • Позволяет одновременное и параллельное выполнение различных задач
  • Уменьшает потребление времени или время отклика, тем самым повышая производительность.

Вот пример, чтобы проверить, сколько времени требуется для выполнения кода с многопоточностью и без нее в python:

 Пример: 
время импорта def sqr (n): для x в n: time.sleep (1) x% 2 def cube (n): для x в n: time.sleep (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) cube (n) e = time.time () print (es)

Вывод:

16.042309284210205

Выше указано время вывода, необходимое для выполнения программы без использования потоков. Теперь давайте воспользуемся потоками и посмотрим, что произойдет с той же программой:

Пример:

import threading из threading import * import time def sqr (n): for x in n: time.sleep (1) print ('Остаток после деления на 2', x% 2) def cube (n): for x in n: time.sleep (1) print ('Остаток после деления на 3', x% 3) n = [1,2,3,4,5,6,7,8] start = time.time () t1 = Thread ( target = sqr, args = (n,)) t2 = Thread (target = cube, args = (n,)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () конец = время. время () печать (конец-начало)
Вывод: 9.040220737457275

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

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

Есть вопрос к нам? Пожалуйста, укажите это в разделе комментариев в блоге «Многопоточность в Python», и мы будем свяжемся с вами как можно скорее.

уроки Visual Studio для начинающих

Чтобы получить более глубокие знания о Python и его различных приложениях, вы можете зарегистрироваться в режиме реального времени. с круглосуточной поддержкой и пожизненным доступом.