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

Разделяемая память — это способ, при котором несколько процессов или потоков могут работать с одной и той же областью памяти. Это даёт быстрый обмен данными без постоянного копирования между процессами. При этом нужно отдельно контролировать синхронизацию, чтобы избежать гонок и повреждения данных.

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

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

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

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

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

from multiprocessing import Process, shared_memory
import numpy as np

def worker(name, size):
    shm = shared_memory.SharedMemory(name=name)
    arr = np.ndarray((size,), dtype=np.int64, buffer=shm.buf)
    arr[0] += 1
    shm.close()

if __name__ == "__main__":
    size = 10
    data = np.zeros(size, dtype=np.int64)

    shm = shared_memory.SharedMemory(create=True, size=data.nbytes)
    shared_arr = np.ndarray(data.shape, dtype=data.dtype, buffer=shm.buf)
    shared_arr[:] = data[:]

    p1 = Process(target=worker, args=(shm.name, size))
    p2 = Process(target=worker, args=(shm.name, size))

    p1.start()
    p2.start()
    p1.join()
    p2.join()

    print(shared_arr)

    shm.close()
    shm.unlink()

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

Код показывает, как два процесса получают доступ к одному и тому же буферу памяти.

В главном процессе создаётся объект SharedMemory, который выделяет общий участок памяти.
Поверх этого буфера создаётся массив NumPy, чтобы удобно работать с числовыми данными.
Каждый дочерний процесс открывает тот же shared memory по имени.
Внутри worker оба процесса изменяют общий массив, в примере — увеличивают первый элемент.
После завершения процессов главный поток читает результат из общей памяти.
В конце память нужно закрыть (close) и освободить системный ресурс (unlink).

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

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

Разделяемая память — это быстрый способ обмена данными между процессами без лишнего копирования.
Для потоков она обычно не нужна, потому что потоки уже разделяют одно адресное пространство.
Главный риск — гонки данных, поэтому часто нужны Lock, Semaphore или другие примитивы синхронизации.
В Python это особенно полезно для больших массивов и вычислительных задач.
После работы с shared memory важно корректно освобождать ресурсы, иначе можно получить утечки системной памяти.

Можете объяснить концепцию разделяемой памяти и её использование в программировании?