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

# Многопоточность в Python

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

1. threading (высокоуровневый API)

Это основной модуль для работы с потоками. Он предоставляет удобный интерфейс:

import threading

def worker():
    print(f"Поток {threading.current_thread().name} работает")

thread = threading.Thread(target=worker, name="WorkerThread")
thread.start()
thread.join()  # Ждём завершения потока

Основные классы:

• Thread — для создания потоков
• Lock — мьютекс для синхронизации
• RLock — рекурсивная блокировка
• Condition — условная переменная
• Semaphore — семафор
• Event — событие для синхронизации
• Barrier — барьер синхронизации

2. queue (безопасные очереди)

Модуль для потокобезопасного обмена данными между потоками:

from queue import Queue

q = Queue(maxsize=10)
q.put("данные")  # Добавить в очередь
data = q.get()   # Получить из очереди

Типы очередей:

• Queue — стандартная FIFO очередь
• LifoQueue — LIFO очередь (стек)
• PriorityQueue — приоритетная очередь

3. _thread (низкоуровневый API)

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

import _thread

def func(name):
    print(f"Поток {name}")

_thread.start_new_thread(func, ("worker",))

4. concurrent.futures (асинхронное выполнение)

Высокоуровневый интерфейс для параллельного выполнения с потоками или процессами:

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=4) as executor:
    future = executor.submit(some_function, arg1, arg2)
    result = future.result()  # Ждём результата

Преимущества:

• Автоматическое управление пулом потоков
• Удобная работа с результатами через Future
• Контекстный менеджер для автоматической очистки

5. multiprocessing (многопроцессность)

Хотя это не совсем многопоточность, это альтернатива для избежания GIL:

from multiprocessing import Process

def worker():
    print("В отдельном процессе")

p = Process(target=worker)
p.start()
p.join()

Важное замечание о GIL

В Python глобальная блокировка интерпретатора (GIL) ограничивает параллельное выполнение кода на процессорных потоках. Это означает, что несколько потоков не могут одновременно выполнять Python-код.

Для действительного параллелизма (CPU-bound операции) используй:

• multiprocessing — отдельные процессы
• asyncio — асинхронное программирование (для I/O-bound операций)
• concurrent.futures.ProcessPoolExecutor — пул процессов

Для I/O-bound операций (сетевые запросы, работа с файлами) потоки работают хорошо, так как во время ожидания I/O GIL освобождается.

Выбор модуля зависит от задачи:

• threading — для простых случаев с I/O операциями
• concurrent.futures — для удобного управления пулом
• queue — для обмена данными между потоками
• multiprocessing — для CPU-bound операций
• asyncio — для современного асинхронного кода (рекомендуется для новых проектов)