Чьей сущностью является процесс

Процесс как сущность операционной системы

Процесс — это сущность операционной системы (ОС), а точнее — экземпляр выполняемой программы, управляемый ядром операционной системы. Это одна из ключевых концепций в системном программировании и важное понимание для Python-разработчика, особенно при работе с многопроцессной обработкой.

Что такое процесс

Процесс — это изолированная среда выполнения, которую ОС создаёт и управляет. Каждый процесс имеет:

• Собственное адресное пространство (memory space): код, данные, стек, куча
• Идентификатор (PID): уникальный номер в системе
• Ресурсы: файловые дескрипторы, сокеты, память
• Состояние: создан (new), готов (ready), выполняется (running), ожидает (waiting), завершён (terminated)

import os
import subprocess

# PID текущего процесса
print(f"Мой PID: {os.getpid()}")

# Запуск нового процесса
proc = subprocess.Popen(["ls", "-la"])
print(f"PID подпроцесса: {proc.pid}")
proc.wait()  # Ждём завершения

Процесс vs Поток (Thread)

Процесс:

• Полностью изолирован
• Собственная память
• Медленнее создавать и переключаться
• Надёжнее (сбой одного не ломает другой)

from multiprocessing import Process

def worker():
    print(f"Процесс {os.getpid()} работает")

if __name__ == "__main__":
    p = Process(target=worker)
    p.start()
    p.join()

Поток:

• Разделяют память одного процесса
• Быстрее создавать
• Общая память → сложнее синхронизировать

from threading import Thread

def worker():
    print(f"Поток работает, PID процесса: {os.getpid()}")

t = Thread(target=worker)
t.start()
t.join()

Жизненный цикл процесса

import os
import signal
import time

# 1. Создание
print(f"Процесс создан: PID {os.getpid()}")

# 2. Выполнение
print("Процесс выполняется...")
time.sleep(2)

# 3. Завершение
print("Процесс завершается")
os.exit(0)  # Код завершения 0 = успешно

Родительский и дочерний процессы

import os
import subprocess

# Родительский процесс
print(f"Родительский процесс: {os.getpid()}")

# Создание дочернего процесса
proc = subprocess.Popen(["sleep", "5"])
print(f"Дочерний процесс: {proc.pid}")
print(f"PPID (родитель дочернего): {os.getppid()}")

proc.wait()
print("Дочерний процесс завершился")

Управление процессами в Python

multiprocessing модуль

from multiprocessing import Process, Pool
import time

def calculate(n):
    return n * n

if __name__ == "__main__":
    # Способ 1: явное управление
    p = Process(target=print, args=("Hello from process",))
    p.start()
    p.join()
    
    # Способ 2: Pool для параллельной обработки
    with Pool(processes=4) as pool:
        results = pool.map(calculate, range(10))
    print(results)

Сигналы и завершение процесса

import os
import signal

# Отправка сигнала процессу
os.kill(pid, signal.SIGTERM)  # Завершить процесс
os.kill(pid, signal.SIGKILL)  # Принудительно завершить

# Обработка сигналов
def handle_signal(signum, frame):
    print("Получен сигнал SIGTERM")
    exit(0)

signal.signal(signal.SIGTERM, handle_signal)

GIL (Global Interpreter Lock) в Python

Важный момент: в Python потоки (threading) не дают истинный параллелизм из-за GIL, но процессы (multiprocessing) работают в полном параллелизме:

from threading import Thread
from multiprocessing import Process
import time

def cpu_bound_task():
    result = sum(i*i for i in range(100_000_000))

start = time.time()

# Потоки будут работать медленнее из-за GIL
threads = [Thread(target=cpu_bound_task) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(f"Потоки: {time.time() - start:.2f}s")

start = time.time()

# Процессы будут работать быстрее
processes = [Process(target=cpu_bound_task) for _ in range(4)]
for p in processes:
    p.start()
for p in processes:
    p.join()
print(f"Процессы: {time.time() - start:.2f}s")

Заключение

Процесс — это фундаментальная единица выполнения в ОС. Понимание процессов критично для:

• Построения масштабируемых систем
• Оптимизации производительности
• Работы с асинхронностью и параллелизмом
• Отладки проблем с ресурсами

Выбор между процессами и потоками зависит от типа задачи (CPU-bound vs I/O-bound).