Потоки: threading и concurrent.futures

import threading, time

def download(name, seconds):
    print(f"  начал {name}")
    time.sleep(seconds)                     # «ждём сеть» — GIL отпущен
    print(f"  закончил {name}")

start = time.perf_counter()
threads = [threading.Thread(target=download, args=(f"файл{i}", 1)) for i in range(3)]
for t in threads:
    t.start()                               # запустить
for t in threads:
    t.join()                                # дождаться завершения
print(f"всего {time.perf_counter() - start:.1f} с")

  начал файл0
  начал файл1
  начал файл2
  закончил файл0
  закончил файл2
  закончил файл1
всего 1.0 с

import threading

counter = 0

def work():
    global counter
    for _ in range(100_000):
        counter += 1                       # НЕ атомарно

threads = [threading.Thread(target=work) for _ in range(8)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)                             # ожидали 800000

617394          # каждый раз разное число

import threading

counter = 0
lock = threading.Lock()

def work():
    global counter
    for _ in range(100_000):
        with lock:                         # только один поток внутри блока
            counter += 1

threads = [threading.Thread(target=work) for _ in range(8)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)                             # 800000 — всегда

lock_a, lock_b = threading.Lock(), threading.Lock()

def transfer_1():
    with lock_a:
        time.sleep(0.1)
        with lock_b: ...       # ждёт lock_b, который держит transfer_2

def transfer_2():
    with lock_b:
        time.sleep(0.1)
        with lock_a: ...       # ждёт lock_a, который держит transfer_1 → deadlock

import threading, queue, time

tasks = queue.Queue()
results = queue.Queue()

def worker(n):
    while True:
        url = tasks.get()                  # блокируется, пока нет задач
        if url is None:                    # маркер завершения
            break
        time.sleep(0.1)                    # «скачиваем»
        results.put((n, url, len(url)))
        tasks.task_done()

workers = [threading.Thread(target=worker, args=(i,)) for i in range(3)]
for w in workers: w.start()
for url in ["a.ru", "bb.ru", "ccc.ru", "dddd.ru", "e.ru"]:
    tasks.put(url)
tasks.join()                               # дождаться обработки всех задач
for _ in workers: tasks.put(None)          # остановить рабочих
for w in workers: w.join()
print(sorted(results.queue, key=lambda r: r[1]))

stop = threading.Event()

def heartbeat():
    while not stop.is_set():
        print("жив")
        stop.wait(1)            # «спим» секунду, но просыпаемся сразу при stop.set()

t = threading.Thread(target=heartbeat); t.start()
time.sleep(2.5); stop.set(); t.join()

from concurrent.futures import ThreadPoolExecutor, as_completed
import urllib.request

URLS = ["https://python.org", "https://pypi.org", "https://docs.python.org", "https://bad.invalid"]

def fetch(url):
    with urllib.request.urlopen(url, timeout=5) as resp:
        return url, len(resp.read())

with ThreadPoolExecutor(max_workers=8) as pool:
    # 1. map — результаты в порядке входных данных
    # sizes = list(pool.map(fetch, URLS))

    # 2. submit + as_completed — по мере готовности, с обработкой ошибок
    futures = {pool.submit(fetch, url): url for url in URLS}
    for future in as_completed(futures, timeout=30):
        url = futures[future]
        try:
            _, size = future.result()           # исключение из потока бросится здесь
            print(f"{url}: {size} байт")
        except Exception as e:
            print(f"{url}: ошибка {type(e).__name__}")

https://pypi.org: 23154 байт
https://python.org: 50417 байт
https://bad.invalid: ошибка URLError
https://docs.python.org: 17996 байт