Skip to content

Зомби, клоны и kill -9. Тайная жизнь процессов в Linux

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

Key Takeaways

  • Процессы в Linux — это активные программы с выделенными ресурсами и уникальными PID.
  • Создание процесса происходит через fork + exec, а не напрямую.
  • Зомби-процессы возникают, если родитель не забирает статус завершения потомка.
  • Сигналы — основной механизм управления процессами, с разными уровнями приоритетов и возможностями обработки.
  • PID процесса может различаться в зависимости от контекста (например, внутри контейнера).

What the video covers

  • Процесс — это запущенная программа с выделенной памятью и ресурсами.
  • Процесс состоит из адресного пространства и записей в ядре, включая потоки.
  • PID — уникальный идентификатор процесса, который может отличаться в контейнерах из-за пространств имён.
  • Процессы рождаются через системный вызов fork, который клонирует процесс, и exec, который загружает новую программу.
  • Первый процесс в системе — systemd с PID 1, он является родителем всех процессов.
  • Процесс умирает через вызов exit, но пока родитель не вызвал wait, процесс остаётся зомби.
  • Зомби-процессы — это завершённые, но не убранные из системы процессы.
  • Сигналы — способ управления процессами, есть разные типы сигналов с разным поведением.
  • Некоторые сигналы, например kill -9, нельзя поймать или игнорировать.
  • Команда kill по умолчанию посылает сигнал TERM (15) — вежливый запрос на завершение.

Answers

Questions about this video

Что такое зомби-процесс в Linux?

Зомби-процесс — это процесс, который завершился, но его родитель не вызвал wait для получения кода завершения, поэтому процесс остаётся в системе как defunct.

Как в Linux создаётся новый процесс?

Новый процесс создаётся через системный вызов fork, который клонирует текущий процесс, а затем exec загружает в него новую программу.

Почему один процесс может иметь разные PID?

Внутри контейнера процесс видит свой PID относительно пространства имён контейнера, а снаружи — относительно хоста, поэтому PID может отличаться.

Full Transcript — Download SRT & Markdown

00:05
Speaker A
Прямо сейчас в твоём компьютере живут зомби, мёртвые программы.
00:16
Speaker A
Они уже завершились, но всё ещё висят в системе, и ты не можешь их просто удалить.
00:38
Speaker A
А ещё здесь есть команда, которая убивает любую программу мгновенно, одним числом, девять, но даже она иногда бессильна.
00:45
Speaker A
[музыка] Чтобы понять, откуда берутся зомби и как правильно прибить зависшую программу, надо сначала разобраться в одной вещи: что вообще такое процесс.
00:54
Speaker A
[музыка]
01:08
Speaker A
И знаешь что? После этого видео ты будешь смотреть на свой Linux совсем другими глазами. Поехали.
01:22
Speaker A
Каждая программа, которую ты запускаешь, браузер, музыка, вот эта самая команда в терминале, превращается в процесс.
01:42
Speaker A
Процесс — это программа, которую система взяла [музыка] и запустила по-настоящему, выдала ей память, время процессора, доступ к файлам.
01:53
Speaker A
[музыка] Из чего он состоит? Из двух вещей.
02:05
Speaker A
Первое — адресное [музыка] пространство. Это куски памяти, которые ядро выделило процессу.
02:21
Speaker A
[музыка] Его код, библиотеки, переменные, стек вызовов, грубо говоря, личная квартира процесса в оперативке.
02:40
Speaker A
Второе — записи внутри ядра. И вот тут интересно. Ядро ведёт на каждый процесс целое досье. Сколько памяти ему выдано, в каком он состоянии, какой у него приоритет, какие файлы и сетевые порты он открыл, какие сигналы он блокирует и
02:53
Speaker A
кто его владелец. Ядро знает про твой процесс буквально всё. Внутри процесса работают потоки. Поток — это отдельная линия выполнения.
03:08
Speaker A
У процесса есть как минимум один поток, но их может быть много. Именно поэтому такие программы, как веб-сервер, обрабатывают тысячи запросов одновременно.
03:18
Speaker A
Они раскидывают их по потокам на разных ядрах процессора. А теперь паспорт процесса. У каждого есть набор атрибутов, и хороший админ обязан их читать.
03:29
Speaker A
[музыка] Главный PID. Айдишник процесса.
03:40
Speaker A
Уникальный номер. Ядро раздаёт их по порядку, по мере рождения. И вот первый сюрприз. В современном Линуксе один и тот же процесс может иметь разные PID в зависимости от того, кто на него смотрит. Внутри контейнера он видит себя как номер один, а снаружи
04:03
Speaker A
на хосте как номер 3000. Это как относительность Эйнштейна, только для процессов. Магия называется пространство имён, и именно на ней держатся все контейнеры.
04:11
Speaker A
Дальше PPID, ID родительского процесса. И вот здесь самое странное во всём Линуксе. В системе нет команды создай мне новый процесс с нуля.
04:23
Speaker A
[музыка] Её просто не существует.
04:39
Speaker A
Единственный способ породить процесс — это когда уже существующий процесс клонирует сам себя. Да, программа делает свою полную копию.
05:01
Speaker A
[музыка] Копию называют дочерним процессом, а оригинал — родительским. Поэтому у любого процесса есть родитель, и его номер — это PPID.
05:23
Speaker A
Ещё атрибуты UID. Кто владелец? От чьего имени процесс бежит. Помнишь сет UID из видео про root и sudo? Вот тут он и выстреливает.
05:37
Speaker A
[музыка] У процесса есть настоящий владелец и эффективный, тот, чьи права реально действуют прямо сейчас.
05:59
Speaker A
[музыка] Точно также есть GID, группа процесса, плюс приоритет. Насколько процесс уступчив к соседям, к нему вернёмся в следующем видео. И управляющий терминал,
06:17
Speaker A
[музыка] то самое окно, из которого нажатие Ctrl C долетит именно до этого процесса.
06:34
Speaker A
[музыка] Хорошо, мы знаем, из чего процесс. Теперь, как он рождается.
06:56
Speaker A
Клонирование делает системный вызов fork. И у fork есть фокус, от которого у новичков взрывается мозг. Fork возвращает два разных значения одновременно.
07:18
Speaker A
Родителю он возвращает номер новорождённого потомка, а самому потомку — ноль. Одна и та же строчка кода в двух процессах даёт разный ответ. Так каждый из них понимает, кто
07:30
Speaker A
[музыка] он: родитель или ребёнок.
07:54
Speaker A
Но стоп. Если процесс просто скопировал сам себя,
08:07
Speaker A
[музыка] получились две одинаковые программы, а нам-то надо запустить другую. И тут выходит второй вызов: exec. Потомок говорит: "Выбрасываю свою старую программу и загружаю на её место новую".
08:27
Speaker A
[музыка] Fork создаёт близнеца, а exec переодевает этого
08:40
Speaker A
близнеца в нужную нам программу. Fork + exec. Вот так в Линуксе запускается вообще всё.
08:46
Speaker A
[музыка] Каждая команда, каждое приложение каждый раз. А самый первый процесс. При загрузке ядро само запускает systemd, и его PID всегда равен один. Мы разбирали
08:57
Speaker A
его в отдельном видео. Это прародитель. Абсолютно все процессы в системе — его потомки, дети его детей. Одно гигантское семейное дерево и в корне единица.
09:04
Speaker A
Итак, процесс родился, поработал, а как он умирает? Когда процесс закончил дела, он вызывает подчёркивание exit, то есть говорит ядру: "Всё, я готов, выключаюсь". И передаёт код завершения — одно число. Ноль по традиции значит, что всё прошло успешно. Любое другое — была
09:12
Speaker A
ошибка. Но вот тонкость. Даже после этого процесс не исчезает сразу. Сначала его родитель обязан забрать тело, сделать вызов wait и считать код завершения потомка. И пока родитель этого не сделал, процесс уже мёртв,
09:20
Speaker A
но всё ещё числится в системе. Вот они, зомби. В списке процессов система показывает их как defunct. Обычно родитель забирает тело мгновенно, и зомби живёт долю секунды. Но если родитель кривой и не сделал wait, зомби зависает.
09:32
Speaker A
Это не вирус и не поломка. Это баг родителя, который забыл похоронить своего ребёнка. А что, если наоборот родитель умер раньше ребёнка? Тогда ребёнок становится сиротой. И тут снова выходит systemd номер один. Он усыновляет всех сирот в системе и потом сам их хоронит. Отец
09:53
Speaker A
всех процессов и могильщик заодно. Окей. А как процессу вообще приказать завершиться? Через сигналы. Сигнал — это короткий тычок процессу, запрос на прерывание. Их больше тридцати. Кто их шлёт? Другой процесс. Драйвер терминала, когда ты жмёшь Ctrl C или Ctrl Z.
10:13
Speaker A
Команда kill или само ядро, например, когда программа делит на ноль или лезет не в свою память. Тогда ядро бьёт её сигналом обычно насмерть.
10:34
Speaker A
Что процесс может сделать с сигналом? Три варианта: поймать, назначить свой обработчик и среагировать, проигнорировать или заблокировать. В очередь разберусь позже. Но есть два сигнала, с которыми это не пройдёт. Их нельзя ни поймать, ни заблокировать, ни проигнорировать.
10:55
Speaker A
[музыка] Это kill и stop. Абсолютное оружие ядра.
11:04
Speaker A
Давай пройдёмся по тем, что обязан знать каждый. TERM номер 15. Вежливая, пожалуйста, доделай дела, приберись и заверши работу. Именно его kill шлёт по умолчанию.
11:21
Speaker A
И номер два — это твой Ctrl C. Запрос: отмени текущую операцию. HUP, у него две жизни. Для демонов это перечитай свой конфиг без перезапуска, а исторически — связь с терминалом оборвалась. Отсюда трюк HUP. Запускаешь программу так, чтобы она пережила
Topics:Linuxпроцессызомби процессыforkexeckillсигналыPIDsystemdпространства имён

Get More with the SozAI App

Transcribe recordings, audio files, and YouTube videos — with AI summaries, speaker detection, and unlimited transcriptions.

Or transcribe another YouTube video here →