Велико лишь то, что долговечно; долговечно лишь то, что справедливо (Д. Феррари).

Многопоточность в Python. Руководство для начинающих

Главное меню » Язык программирования Python » Многопоточность в Python. Руководство для начинающих

(1 оценок, среднее: 5,00 из 5)

Загрузка...

18.07.2017

Многопоточность является основной программирования программного обеспечения на языке высокого уровня. И многопоточность в Python, один из лучших примеров упрощенной реализации потоков.

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

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

В данной статье мы научим вас различным методам для создания потоков и осуществлять синхронизацию. Давайте сначала посмотрим на некоторые из основных преимуществ и недостатков многопоточности.

Многопоточность в Python — Плюсы:

Многопоточность может значительно улучшить скорость вычислений на многопроцессорных или многоядерных системах, так как каждый процессор или ядро обрабатывает отдельный поток одновременно.
Многопоточность позволяет программе оставаться отзывчивой в то время как один поток ожидает ввода, другой работает как графический интерфейс. Это утверждение справедливо как для многопроцессорных или однопроцессорных систем.
Все нити процесса имеют доступ к своим глобальным переменным. Если глобальная переменная изменяется в одном потоке, то видима и для других потоков также. Поток может также иметь свои собственные локальные переменные.

Многопоточность в Python — Минусы:

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

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

Модули многопоточности в Python для реализации нитей.

Python предлагает два модуля для реализации threads в программах.

модуль <thread>
модуль <threading>.

Для вашей информации, модуль <thread> является устаревшим в Python 3 и переименован в модуль <_thread> для обратной совместимости. Но мы объясним оба метода, так как многие пользователи все еще используют унаследованные версии Python.

Основное различие между этими двумя модулями является то, что модуль <thread> реализует нить как функцию. С другой стороны, модуль <threading> предлагает объектно-ориентированный подход для обеспечения возможности создания потоков.

1- Как использовать модуль thread для создания потоков.

Если вы решите применить модуль <thread> в вашей программе, то необходимо использовать следующий метод порождения потоков.

Многопоточность в Python: использование модуля thread

thread.start_new_thread ( function, args[, kwargs] )

Этот метод является достаточно простым и эффективным способом создания потоков. Вы можете использовать его для запуска программ в Linux, так и Windows.

Этот метод запускает новый поток и возвращает его идентификатор. Он будет вызывать функцию, заданную в качестве параметра «function» с переданным списком аргументов. Когда <function> возвращает, поток выходит.

Здесь арг является кортеж аргументов; используя пустой кортеж для вызова <function> без каких — либо аргументов. Необязательный параметр < kwargs > определяет словарь ключевых аргументов.

Если <function> завершается с необработанным исключением, печатается трассирование, а затем выходит нить (Это не влияет на другие потоки, они продолжают работать). Используйте приведенный ниже код, чтобы узнать больше о многопоточности.

Основной пример многопоточности в Python.

Многопоточность в Python: вызов функции факториала из потока.

#Пример многопоточности в Python.
#1. Вычислить факториал с помощью рекурсии.
#2. Вызов функции факториала с помощью thread.
 
from thread import start_new_thread
 
threadId = 1
 
def factorial(n):
   global threadId
   if n < 1:   # базовый вариант
       print "%s: %d" % ("Нить", threadId )
       threadId += 1
       return 1
   else:
       returnNumber = n * factorial( n - 1 )  # рекурсивный вызов
       print(str(n) + '! = ' + str(returnNumber))
       return returnNumber
 
start_new_thread(factorial,(5, ))
start_new_thread(factorial,(4, ))
 
c = raw_input("Ждем поток для возврата...\n")

После выполнения программы, вывод будет следующим.

Вывод программы.

Многопоточность в Python: вывод в многопоточных программах.

# Многопоточность в Python: вывод программы -
Ждем поток для возврата...
Нить: 1
1! = 1
2! = 2
3! = 6
4! = 24
Нить: 2
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120

2 — Как использовать модуль threading для создания темы.

Последний модуль <threading> предоставляет богатые возможности и большую поддержку потоков, чем унаследованный модуль <thread>, рассмотренный в предыдущем разделе. Модуль <threading> является отличным примером многопоточности в Python.

Модуль <threading> объединяет все методы модуля <thread> и предоставляет несколько дополнительных методов.

threading.activeCount(): находит общее количество активных объектов thread.
threading.currentThread(): вы можете использовать его, чтобы определить количество объектов thread под контролем потока вызывающего потока.
threading.enumerate(): даст вам полный список объектов нитей, которые активны в настоящее время.

Помимо перечисленных выше методов, модуль <threading> также представляет класс <Thread>, который вы можете попробовать для реализации thread. Это объектно-ориентированный вариант многопоточности в Python.

Класс <Thread> публикует следующие методы.

Методы класса	Метод Описание
run():	Это функция точки входа для любого потока.
start():	Способ start() запускает поток, когда вызывается метод run.
join([time]):	Метод join() позволяет программе ожидать оканчиваются.
isAlive():	Метод isAlive() проверяет активную нить.
getName():	Метод getName() возвращает имя потока.
setName():	Метод setName() обновляет имя потока.

2.1- Шаги для реализации темы с помощью модуля threading.

Вы можете выполнить следующие шаги, чтобы реализовать новый поток, используя модуль <threading>

Построить подкласс от класса <Thread>.
Переопределение <__init__(self [,args])> как способ поставки аргументов в соответствии с требованиями.
Затем переопределить метод <run(self [,args])> для кодирования бизнес-логики потока.

После того, как вы определите новый подкласс <Thread>, вы должны создать экземпляр, чтобы начать новый поток. Затем, вызовите метод <start()>, чтобы инициировать его. Это в конечном счете вызовет метод <run()> для выполнения бизнес — логики.

Пример — Создание класса потоков и объектов для печати текущей даты.

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

# Многопоточность в Python: пример кода для отображения текущей даты в потоке.
#1. Определить подкласс, используя класс thread.
#2. Создать экземпляр подкласса и вызвет поток.
 
import threading
import datetime
 
class myThread (threading.Thread):
    def __init__(self, name, counter):
        threading.Thread.__init__(self)
        self.threadID = counter
        self.name = name
        self.counter = counter
    def run(self):
        print "Запуск " + self.name
        print_date(self.name, self.counter)
        print "Выход " + self.name
 
def print_date(threadName, counter):
    datefields = []
    today = datetime.date.today()
    datefields.append(today)
    print "%s[%d]: %s" % ( threadName, counter, datefields[0] )
 
# Создание новой нити
thread1 = myThread("Нить", 1)
thread2 = myThread("Нить", 2)
 
# Запуск новой нити
thread1.start()
thread2.start()
 
thread1.join()
thread2.join()
print "Выход из программы!!!"

2.2- Python Многопоточность — Синхронизация потоков.

Модуль <threading> имеет встроенные функциональные возможности для осуществления блокировки, что позволяет синхронизировать потоки. Блокировка требуется для управления доступом к общим ресурсам для предотвращения повреждения или непринятых данных.

Вы можете вызвать метод Lock(), чтобы применять блокировки, он возвращает новый объект блокировки. Затем, вы можете вызвать метод acquire(blocking) объекта блокировки для обеспечения синхронного выполнения потоков.

Необязательный параметр blocking указывает, ожидает ли нить получения блокировки.

В случае, если blocking устанавливается равным нулю, то поток сразу же возвращается с нулевым значением, если блокировка не может быть получена и с 1, если блокировка была приобретена.
В случае, если blocking устанавливается в 1, поток блоков ожидает, пока замок освободиться блокировка.

Метод release() объекта блокировки используется для снятия блокировки, когда он больше не требуется.

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

Пример многопоточности в Python для демонстрации блокировки.

Многопоточность в Python: пример кода, демонстрации блокировки.

# Многопоточность в Python: пример кода, демонстрации блокировки.
#1. Определить подкласс, используя класс thread.
#2. Создать экземпляр подкласса и вызвать поток.
#3. Реализуем locks в потоке методом run.
 
import threading
import datetime
 
exitFlag = 0
 
class myThread (threading.Thread):
    def __init__(self, name, counter):
        threading.Thread.__init__(self)
        self.threadID = counter
        self.name = name
        self.counter = counter
    def run(self):
        print "Запуск " + self.name
        # Получить lock для синхронизации потоков
        threadLock.acquire()
        print_date(self.name, self.counter)
        # Фиксатор для следующего потока
        threadLock.release()
        print "Выход " + self.name
 
def print_date(threadName, counter):
    datefields = []
    today = datetime.date.today()
    datefields.append(today)
    print "%s[%d]: %s" % ( threadName, counter, datefields[0] )
 
threadLock = threading.Lock()
threads = []
 
# Создание нового потока
thread1 = myThread("Нить", 1)
thread2 = myThread("Нить", 2)
 
# Запуск нового потока
thread1.start()
thread2.start()
 
# Добавлять потоки в список нитей
threads.append(thread1)
threads.append(thread2)
 
# Ждать для всех потоков, чтобы завершить
for t in threads:
    t.join()
print "Выход из программы!!!"

Основная информация — Многопоточность в Python. Руководство для начинающих

Мы хотим, чтобы вы нашли это руководство по многопоточности в Python очень интересным и интуитивно понятным. Кроме того, мы добавили несколько примеров в этом руководстве, что, несомненно, поможет вам поднять ваши навыки Python.

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.