Что такое PID?

PID — Process ID в операционных системах

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

Основное определение

PID — это натуральное число (обычно целое число), которое однозначно идентифицирует процесс в системе в определённый момент времени. После завершения процесса его PID может быть переиспользован другим процессом.

Диапазон PID

Диапазон PID зависит от ОС:

• Linux: обычно от 1 до 32768 (или больше в современных системах)
• Windows: использует другую нумерацию через объекты ядра
• macOS: похоже на Linux

Как получить PID

import os
import subprocess

# Получить PID текущего процесса
current_pid = os.getpid()
print(f"Мой PID: {current_pid}")  # Например: Мой PID: 12345

# Получить PID родительского процесса
parent_pid = os.getppid()
print(f"PID родителя: {parent_pid}")

# Запустить подпроцесс и получить его PID
proc = subprocess.Popen(['python', 'script.py'])
child_pid = proc.pid
print(f"PID дочернего процесса: {child_pid}")

# Ждём завершения процесса
proc.wait()

Shell команды для работы с PID

# Получить PID текущей shell
echo $$

# Получить PID процесса Python
pgrep python

# Получить все информацию о процессе
ps aux | grep python

# Найти процесс по имени и убить его
pkill -f "python script.py"

# Список всех процессов с их PID
ps -e

# Мониторинг процессов в реальном времени
top

# Статус конкретного процесса
ps -p 12345 -o pid,ppid,cmd,etime

PID и дочерние процессы

Когда процесс создаёт дочерний процесс, они имеют разные PID:

import os
import time

def show_process_info():
    print(f"PID процесса: {os.getpid()}")
    print(f"PID родителя: {os.getppid()}")

if __name__ == "__main__":
    print("=== Основной процесс ===")
    show_process_info()
    
    # Создать дочерний процесс
    if os.fork() == 0:  # Это дочерний процесс
        print("\n=== Дочерний процесс ===")
        show_process_info()
        exit(0)
    else:  # Это основной процесс
        time.sleep(1)  # Дать дочернему времени выполниться

Управление процессами через multiprocessing

from multiprocessing import Process
import os
import time

def worker(name):
    print(f"Работник {name} запущен с PID {os.getpid()}")
    time.sleep(2)
    print(f"Работник {name} завершен")

if __name__ == "__main__":
    print(f"Основной процесс PID: {os.getpid()}")
    
    # Создать несколько параллельных процессов
    processes = []
    for i in range(3):
        p = Process(target=worker, args=(f"Process-{i}",))
        p.start()
        processes.append(p)
        print(f"Создан процесс {i} с PID {p.pid}")
    
    # Ждём завершения всех процессов
    for p in processes:
        p.join()
    
    print("Все процессы завершены")

Отправка сигналов процессам

C помощью PID можно отправлять сигналы процессам:

import os
import signal
import time
from multiprocessing import Process

def long_running_task():
    try:
        print(f"Задача запущена PID {os.getpid()}")
        for i in range(10):
            print(f"Работаю... {i}")
            time.sleep(1)
    except KeyboardInterrupt:
        print("Получен SIGINT, завершаю работу")

if __name__ == "__main__":
    p = Process(target=long_running_task)
    p.start()
    print(f"Дочерний процесс: {p.pid}")
    
    time.sleep(3)
    
    # Отправить сигнал SIGTERM процессу
    os.kill(p.pid, signal.SIGTERM)
    
    # Ждём завершения
    p.join(timeout=5)
    if p.is_alive():
        # Если не завершился, отправить SIGKILL
        os.kill(p.pid, signal.SIGKILL)

Мониторинг процессов через psutil

import psutil
import os

# Получить текущий процесс
current_process = psutil.Process(os.getpid())

print(f"PID: {current_process.pid}")
print(f"Имя: {current_process.name()}")
print(f"Статус: {current_process.status()}")
print(f"Использование CPU: {current_process.cpu_percent()}%")
print(f"Использование памяти: {current_process.memory_info().rss / 1024 / 1024:.2f} MB")
print(f"Количество потоков: {current_process.num_threads()}")

# Получить информацию обо всех процессах
for proc in psutil.process_iter(['pid', 'name', 'status']):
    if 'python' in proc.info['name'].lower():
        print(f"PID: {proc.info['pid']}, Имя: {proc.info['name']}, Статус: {proc.info['status']}")

# Получить процесс по PID
try:
    p = psutil.Process(12345)
    print(p.as_dict())
except psutil.NoSuchProcess:
    print("Процесс не найден")

Зомби-процессы и PID

Зомби-процесс (Zombie Process) — это процесс, который завершился, но его родитель ещё не прочитал его статус выхода:

import os
import subprocess
import time

# Создать зомби-процесс
proc = subprocess.Popen(['sleep', '1'])
print(f"Создан процесс с PID {proc.pid}")
print("Даём ему время завершиться...")
time.sleep(2)

# Процесс завершился, но родитель не вызвал wait()
# В этом момент это зомби

# Правильно: вызвать wait()
returncode = proc.wait()
print(f"Процесс завершился с кодом {returncode}")

Контейнеры и PID

В Docker контейнерах PID переизначается:

# В контейнере ваш процесс может иметь PID 1
# даже если на хосте он имеет другой PID
docker ps  # Увидите разные PID для одного контейнера

# Внутри контейнера
echo $$  # Может быть 1
# На хосте
docker top <container_id>  # Будет другой PID

Практическое применение

1. Отладка — найти процесс, который занимает много ресурсов
2. Мониторинг — отслеживать запущенные приложения
3. Управление процессами — отправлять сигналы завершения
4. Логирование — включать PID в логи для отладки
5. Блокировка файлов (PID file) — /.run/app.pid

Лучшие практики

1. Всегда вызывайте wait() на дочерних процессах, чтобы избежать зомби-процессов
2. Используйте context managers для управления процессами
3. Логируйте PID для лучшей отладки в распределённых системах
4. Мониторьте процессы в production через системы как Prometheus

PID — это неотъемлемая часть работы операционной системы, и понимание его помогает в отладке, мониторинге и управлении приложениями.