Какие плюсы и минусы многопоточности (multithreading)?

Плюсы и минусы многопоточности (Multithreading)

ПЛЮСЫ

1. Улучшение отзывчивости приложения

Длительные операции не блокируют главный поток.

import threading
import time

def blocking_operation():
    """Имитация долгой операции"""
    time.sleep(3)
    print("Операция завершена")

# БЕЗ многопоточности: UI зависает на 3 секунды
blocking_operation()
print("Приложение снова отзывчиво")  # Ждёт 3 сек

# С многопоточностью: UI отзывчив сразу
thread = threading.Thread(target=blocking_operation)
thread.start()
print("Приложение отзывчиво!")  # Выполняется сразу

2. Использование множественных ядер (частично)

Хотя GIL ограничивает CPU-bound, I/O-bound операции параллелизируются эффективно.

import threading
import requests
from concurrent.futures import ThreadPoolExecutor

def fetch_url(url):
    """I/O-bound операция"""
    response = requests.get(url)
    return len(response.content)

urls = [http://example.com, http://google.com, http://github.com]

# Без многопоточности: ~3 сек (последовательно)
for url in urls:
    fetch_url(url)

# С многопоточностью: ~1 сек (параллельно)
with ThreadPoolExecutor(max_workers=3) as executor:
    results = list(executor.map(fetch_url, urls))

3. Естественное моделирование concurrent процессов

Некоторые задачи по своей природе асинхронные (веб-сервер, игра).

def handle_client(client_socket):
    """Обработка каждого клиента в отдельном потоке"""
    data = client_socket.recv(1024)
    response = process_request(data)
    client_socket.send(response)

# Каждое соединение = отдельный поток
while True:
    client, addr = server_socket.accept()
    thread = threading.Thread(target=handle_client, args=(client,))
    thread.start()

МИНУСЫ

1. GIL (Global Interpreter Lock)

В CPython только один поток может выполнять Python-код одновременно. CPU-bound задачи не распараллеливаются.

import threading
import time

def cpu_bound_task():
    """CPU-intensive операция"""
    total = 0
    for i in range(100_000_000):
        total += i
    return total

start = time.time()

# Без многопоточности: 5 сек (2 вычисления)
cpu_bound_task()
cpu_bound_task()
print(f"Sequential: {time.time() - start:.2f}s")  # 5 сек

start = time.time()

# С многопоточностью: ~5 сек (не быстрее!)
threads = [
    threading.Thread(target=cpu_bound_task),
    threading.Thread(target=cpu_bound_task)
]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(f"Multithreaded: {time.time() - start:.2f}s")  # Всё ещё 5 сек

Решение: используй multiprocessing для CPU-bound.

2. Race Conditions и Data Races

Без синхронизации несколько потоков могут одновременно менять общие данные.

# ОПАСНО: Race condition
counter = 0

def increment():
    global counter
    for _ in range(100_000):
        counter += 1  # НЕ АТОМАРНА!

threads = [threading.Thread(target=increment) for _ in range(2)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter)  # Ожидаем 200_000, но получим меньше (например, 165_432)

# ПРАВИЛЬНО: С lock
import threading

lock = threading.Lock()
counter = 0

def increment():
    global counter
    for _ in range(100_000):
        with lock:
            counter += 1

threads = [threading.Thread(target=increment) for _ in range(2)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter)  # 200_000 ✓

3. Deadlock

Потоки могут заблокировать друг друга при неправильном использовании блокировок.

# DEADLOCK
lock1 = threading.Lock()
lock2 = threading.Lock()

def thread1_func():
    with lock1:
        time.sleep(0.1)
        with lock2:  # Ждёт lock2, который держит thread2
            pass

def thread2_func():
    with lock2:
        time.sleep(0.1)
        with lock1:  # Ждёт lock1, который держит thread1
            pass

t1 = threading.Thread(target=thread1_func)
t2 = threading.Thread(target=thread2_func)
t1.start()
t2.start()
# Программа зависнет!

# РЕШЕНИЕ: Заказывай блокировки в одинаковом порядке
def fixed_thread1():
    with lock1:
        time.sleep(0.1)
        with lock2:
            pass

def fixed_thread2():
    with lock1:  # Первым lock1!
        time.sleep(0.1)
        with lock2:
            pass

4. Сложность отладки

Ошибки в многопоточном коде трудно воспроизвести и отследить.

# Ошибка может случиться в 1% запусков
# Сложно воспроизвести и понять причину
def unpredictable_bug():
    if threading.current_thread() is not threading.main_thread():
        # Иногда падает, иногда нет
        shared_list.append(1)

5. Overhead контекстного переключения

Создание и переключение потоков требует ресурсов.

import threading
import time

def light_task():
    return sum(range(100))

start = time.time()
for _ in range(10_000):
    light_task()  # Быстро
print(f"Sequential: {time.time() - start:.4f}s")

start = time.time()
threads = [threading.Thread(target=light_task) for _ in range(10_000)]
for t in threads:
    t.start()
for t in threads:
    t.join()  # Медленнее из-за overhead
print(f"Multithreaded: {time.time() - start:.4f}s")

6. Memory Overhead

Каждый поток требует памяти для стека (обычно 8 МБ). Тысячи потоков = гигабайты памяти.

Когда использовать multithreading?

✅ I/O-bound операции:

• Сетевые запросы
• Файловые операции
• Операции с БД

❌ CPU-bound операции:

• Математические расчёты
• Обработка изображений
• Компрессия данных → Используй multiprocessing

Альтернативы

# 1. asyncio - для I/O-bound (без потоков)
import asyncio

async def fetch_multiple_urls():
    tasks = [fetch_url(url) for url in urls]
    results = await asyncio.gather(*tasks)  # Параллельно
    return results

# 2. multiprocessing - для CPU-bound
from multiprocessing import Pool

with Pool(4) as p:
    results = p.map(cpu_bound_task, data)

# 3. ThreadPoolExecutor - удобная обёртка
from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(task, data))