Когда используется поток?

Когда используется поток (Threading) в Python

Потоки (threads) — это механизм параллелизма, который позволяет выполнять несколько задач в пределах одного процесса. Используются в следующих ситуациях:

1. I/O-bound операции

Это основной случай использования потоков в Python:

• Сетевые запросы: HTTP запросы, подключения к API, работа с веб-сокетами
• Файловые операции: чтение/запись на диск, работа с большими файлами
• Работа с БД: запросы к базам данных, особенно если они блокируют

import threading
import requests

def fetch_url(url):
    response = requests.get(url)
    print(f"Fetched {url}: {len(response.content)} bytes")

threads = []
urls = ["https://api.example.com/1", "https://api.example.com/2"]

for url in urls:
    t = threading.Thread(target=fetch_url, args=(url,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

В этом примере потоки не заблокируют друг друга при ожидании ответа от сервера.

2. Отзывчивый UI

В приложениях с пользовательским интерфейсом потоки позволяют выполнять длительные операции без "зависания" программы:

import threading
import tkinter as tk

def long_operation():
    # Долгая операция
    result = sum(range(1000000000))
    label.config(text=f"Result: {result}")

root = tk.Tk()
label = tk.Label(root, text="Processing...")
label.pack()

button = tk.Button(
    root,
    text="Start",
    command=lambda: threading.Thread(target=long_operation, daemon=True).start()
)
button.pack()
root.mainloop()

Основной поток остаётся свободным для обработки событий UI.

3. Фоновые задачи

Демон-потоки идеальны для фоновых работ, которые должны выполняться параллельно:

import threading
import time

def background_logger():
    while True:
        print(f"[LOG] Current time: {time.time()}")
        time.sleep(5)

logger_thread = threading.Thread(target=background_logger, daemon=True)
logger_thread.start()

# Основная программа продолжает работу
for i in range(3):
    print(f"Main thread: {i}")
    time.sleep(2)

4. Конкурентные операции с общим состоянием

Когда нужно безопасно обновлять общие ресурсы:

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:
        temp = counter
        temp += 1
        counter = temp

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

print(f"Counter: {counter}")  # 5 (безопасно)

Когда НЕ использовать потоки

CPU-bound операции: Из-за GIL (Global Interpreter Lock), потоки не дают ускорения для вычислений. Используйте multiprocessing вместо:

# ❌ Плохо для CPU-bound
import threading

def cpu_heavy():
    return sum(range(100000000))

threads = [threading.Thread(target=cpu_heavy) for _ in range(4)]

# ✅ Хорошо для CPU-bound
from multiprocessing import Pool

with Pool(4) as p:
    results = p.map(lambda _: cpu_heavy(), range(4))

Итого

Используй потоки когда:

• I/O операции (сеть, файлы, БД)
• Нужна отзывчивость UI
• Фоновые задачи
• Конкурентный доступ к ресурсам

Не используй потоки когда:

• CPU-интенсивные вычисления (GIL помешает)
• Нужен истинный параллелизм (используй multiprocessing)