Python - Многопоточность

Привет, будущие маги Python! Сегодня мы отправляемся в захватывающее путешествие в мир многопоточности в Python. Не волнуйтесь, если вы новичок в программировании; я стану вашим дружелюбным гидом, и мы будем исследовать эту тему шаг за шагом. Так что взяйте ваши виртуальные палочки (клавиатуры), и давайте погружимся!

Python - Multithreading

Что такое многопоточность?

Прежде чем мы начнем работать с потоками Python, давайте поймем, что такое многопоточность. Представьте себе, что вы шеф-повар в оживленной кухне. Если вы готовите один, вы можете выполнять только одну задачу за раз – нарезать овощи, затем кипятить воду, затем жарить мясо. Но что если у вас было несколько рук, которые могли бы выполнять разные задачи одновременно? Вот что делает многопоточность для наших программ!

Многопоточность позволяет программе выполнять несколько задач одновременно в пределах одного процесса. Это как если у вас было несколько поваров (потоков), работающих вместе на одной кухне (процесс), чтобы приготовить вкусное блюдо (выход программы) быстрее и более эффективно.

Сравнение с процессами

Теперь вы можете подумать: "Но учитель, я слышал и про процессы. В чем разница?" Отличный вопрос! Разберем это:

Использование ресурсов: Потоки как братья и сестры, делящие комнату (память), в то время как процессы как соседи с отдельными домами. Потоки легче и делят ресурсы, что делает их более эффективными для определенных задач.
Связь: Потоки могут легко общаться, делясь переменными, а процессы должны использовать специальные "телефоны" (взаимодействие между процессами) для общения.
Нагрузка: Создание и управление потоками обычно происходит быстрее и требует меньше системных ресурсов по сравнению с процессами.
Сложность: Хотя потоки могут сделать вашу программу быстрее, они также вводят сложность. Это как жонглирование – забавно и эффективно, когда делается правильно, но вы можете уронить мяч, если не будете осторожны!

Модули управления потоками в Python

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

threading: Это высокоуровневый интерфейс для работы с потоками. Это как дружелюбный ученик волшебника, который делает большую часть тяжелой работы за вас.
_thread: Это низкоуровневый интерфейс. Это как древний гримуар – мощный, но требует больше мастерства для правильного использования.

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

Запуск нового потока

Хорошо, давайте поднимем наш первый потоковый заклинание! Вот как мы создаем и запускаем новый поток:

import threading
import time

def print_numbers():
for i in range(5):
time.sleep(1)
print(f"Поток 1: {i}")

# Создание нового потока
thread1 = threading.Thread(target=print_numbers)

# Запуск потока
thread1.start()

# Основной поток продолжает выполнение
for i in range(5):
time.sleep(1)
print(f"Основной поток: {i}")

# Ожидание завершения thread1
thread1.join()

print("Все выполнено!")

Разберем это заклинание:

Мы импортируем модули threading и time.
Мы определяем функцию print_numbers(), которая будет выполняться нашим потоком.
Мы создаем новый объект потока, указывая функцию, которую он должен запустить.
Мы запускаем поток с помощью метода start().
Основной поток продолжает выполнение своего цикла.
Мы используем join() для ожидания завершения нашего потока перед завершением программы.

Когда вы выполните это, вы увидите числа из обоих потоков, переплетающиеся, демонстрируя одновременное выполнение!

Синхронизация потоков

Теперь представьте, что наши помощники повара пытаются использовать один и тот же нож одновременно – хаос, правда? Вот где входит синхронизация потоков. Мы используем блокировки, чтобы убедиться, что только один поток может получить доступ к общему ресурсу одновременно.

Вот пример:

import threading
import time

# Общий ресурс
счетчик = 0
lock = threading.Lock()

def increment_counter():
global счетчик
for _ in range(100000):
lock.acquire()
счетчик += 1
lock.release()

# Создание двух потоков
thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

# Запуск потоков
thread1.start()
thread2.start()

# Ожидание завершения обоих потоков
thread1.join()
thread2.join()

print(f"Конечное значение счетчика: {счетчик}")

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

Многопоточная приоритетная очередь

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

import threading
import queue
import time
import random

# Создание приоритетной очереди
task_queue = queue.PriorityQueue()

def worker():
while True:
priority, task = task_queue.get()
print(f"Обработка задачи: {task} (Приоритет: {priority})")
time.sleep(random.uniform(0.1, 0.5))  # Симуляция работы
task_queue.task_done()

# Создание и запуск рабочих потоков
for _ in range(3):
thread = threading.Thread(target=worker, daemon=True)
thread.start()

# Добавление задач в очередь
for i in range(10):
priority = random.randint(1, 5)
task = f"Задача {i}"
task_queue.put((priority, task))

# Ожидание завершения всех задач
task_queue.join()
print("Все задачи выполнены!")

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

Заключение

Поздравляем, молодые Python-мастера! Вы только что сделали свои первые шаги в волшебном мире многопоточности. Помните, с большой силой приходит большая ответственность – используйте потоки мудро, и они сделают ваши программы быстрее и более эффективными.

Вот быстрый справочник по основным методам работы с потоками, которые мы рассмотрели:

Метод	Описание
`Thread(target=function)`	Создает новый поток для выполнения указанной функции
`start()`	Запускает деятельность потока
`join()`	Ожидает завершения потока
`Lock()`	Создает блокировку для синхронизации потоков
`acquire()`	Захватывает блокировку
`release()`	Освобождает блокировку

Практикуйтесь, будьте любознательными, и скоро вы сможете направлять потоки, как настоящий Python-маestro! Счастливого кодирования!

Credits: Image by storyset

Предыдущий учебник:

Python - Встроенные исключения

Следующий учебник:

Python - Цикл жизни потока