Что хотят услышать интервьюеры:

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

Определение:

Обмен информацией между параллельными исполнителями — это способы, с помощью которых потоки, процессы или другие компоненты передают данные, координируют выполнение и избегают конфликтов при доступе к общим ресурсам.

В Python основные подходы такие:

Общая память — доступ к одним и тем же объектам или структурам данных, но с синхронизацией через Lock, RLock, Semaphore, Condition.
Очереди — безопасная передача сообщений через queue.Queue для потоков и multiprocessing.Queue для процессов.
События и условия — уведомление о наступлении состояния через Event, Condition.
Пайпы и каналы — чаще в межпроцессном взаимодействии.
IPC и shared memory — обмен между процессами через разделяемую память, сокеты, файлы, менеджеры.

Пример использования:

Нужно обработать данные в нескольких потоках: один поток кладёт задачи в очередь, другие забирают и обрабатывают их.

from queue import Queue
from threading import Thread

def producer(q):
    for i in range(5):
        q.put(i)
    q.put(None)  # маркер завершения

def consumer(q):
    while True:
        item = q.get()
        if item is None:
            q.put(None)  # передать сигнал дальше, если потребителей несколько
            break
        print(f"Обработано: {item}")

q = Queue()

t1 = Thread(target=producer, args=(q,))
t2 = Thread(target=consumer, args=(q,))

t1.start()
t2.start()

t1.join()
t2.join()

Пояснение кода:

Код показывает обмен данными через Queue, которая безопасна для использования из нескольких потоков.

producer помещает значения в очередь через put.
consumer извлекает их через get.
None используется как сигнал завершения работы.
Очередь сама обеспечивает нужную синхронизацию, поэтому не нужно вручную защищать доступ к ней Lock.
join() у потоков нужен, чтобы дождаться завершения работы обоих потоков.

Ключевые моменты:

Для потоков самый удобный и безопасный способ обмена данными — queue.Queue.
Для процессов используют multiprocessing.Queue, Pipe, Value, Array, Manager, shared memory.
Если есть общие данные, нужен механизм синхронизации: Lock, RLock, Semaphore, Condition, Event.
Если нужна модель “передача сообщений вместо общей памяти”, очередь обычно предпочтительнее.
В Python для потоков важно помнить про GIL: он не делает код потокобезопасным, а только ограничивает параллельное выполнение байткода.
Для межпроцессного обмена чаще выбирают очереди или IPC, потому что память у процессов раздельная.

Какими способами осуществляется взаимодействие и обмен информацией между параллельными компонентами или потоками в системе?