Linux список процессов по ядрам

Linux: ядро (kernel), процессы /proc в ОС и работа с ними (proc, ps, kill, top, lsof)

В Linux все рассматривается как файлы, включая устройства (/dev) и процессы (/proc).

Процессы запускаются самой системой для функционирования системы, такие процессы называют background/daemon process. Разделение на application и background processes можно увидеть в Windows taskmanager.

Одна программа может инициировать множество процессов (chrome, mediaplayer). При запуске процесс получает Process ID (PID, уникальный идентификатор процесса). Так же каждый процесс запрашивает физические ресурсы у ядра системы – CPU, RAM, HDD/SDD (i/o), NIC. При завершении процесса (автоматически или вручную) ресурсы возвращаются обратно ядру. Особенно удобно потребление ресурсов просмотривать в Мониторинге ресурсов (Windows) или top (Linux).

Процессы в linux построены в древовидной структуре – почти каждый процесс имеет своего родителя, кроме init/kthreadd (см. ps -auxf или ps -ef). Справедливо и при использовании pipe – cat 1 | grep 2 – grep будет являться дочерним для cat.

В Linux дочерние процессы не могут работать независимо от родительских, в отличии от Windows (там дочерний процесс связан с родительским только в момент создания – заимствует environment:переменные/настройки). Видно это например при запуске из консоли приложения – если в Windows убить консоль, то с приложением ничего не будет, в отличии от Linux, который дропнет child процесс при отключении родительского (поэтому так полезны в Linux демоны/сервисы/screen).

Процессам можно передавать сигналы Sig/Signals. Ctrl-c и в Windows и в Linux передает сигнал sigint (signal interrupt), который шлет прерывание процесса от системы процессу. В отличии от Linux, в Windows пользователю сложно отправить произвольный сигнал программе с командной строки (кроме прерывания ctrl-c). В Linux же таких сигналов очень много (смотрим через kill -l) и их можно отправить через kill, начинаются они по названию с приставки SIG (сокращенно от Signal, например sigint).

У процессов есть приоритет исполнения на CPU – задачи с повышенном приоритетом исполняются первыми. В случае с Linux это называется niceness (nice value), значения в range от -20 до +19. Большая часть процессов по умолчанию запускается с значением 0. Чем НИЖЕ значение nice у процесса, тем ВЫШЕ ее приоритет. Child процесс наследует nice значение у родительского. Посмотреть значение nice можно в top или по ps -efl.

Просмотр

ps (в Windows taskmanager ctrl-shift-esc, tasklist/get-process, process explorer) – позволяет посмотреть процессы, запущенные в системе. По умолчанию, ps показывает только принадлежащие вам процессы (freebsd) или только принадлежащие текущему терминалу pts (Linux).

Альтернатива – просмотр папок для PID в /proc/

. Оттуда ps (так же как и другие команды, например top), берет информацию о процессах. В этой папке можно найти всю-всю-всю информацию о конкретном процессе.

Популярные наборы опций:

init – первый процесс стартуемый в системе linux. Имеет pid 1. Стартует другие процессы необходимые для работы системы.

• USER – какой пользователь запустил процесс
• %CPU/%MEM – сколько CPU/MEM потребляет процесс
• PID – ID процесса
• PPID – ID родительского процесса (ps -ef)
• С – ID child процесса (ps -ef)
• TTY – терминал, связанный с процессом
• STAT – статус процесса, в один конкретным момент может быть только один статус
  • R:Running – работает (исполняется CPU прямо сейчас),
  • T:Stopped/Suspended – приостановлен (например через kill -20) и не будет исполнен, пока процесс не получит сигнал,
  • S:Sleeping – interruptible sleep – ждет события (пользовательского ввода, другого процесса) для продолжения
  • Waiting – sleeping процесс, который получил нужные данные для продолжения, но ждет очереди
  • Zombie – мертвый процесс, который есть в таблице с процессами, но ресурсы он не потребляет. Существует пока родитель не скажет ему умереть (или не умрет сам).

• STIME/START – когда запущен процесс
• TIME – время которое CPU обрабатывает процесс (совокупное)

• COMMAND – исполняемая команда/процесс. При использовании флага -f совместно с -aux (-auxf) показывается дерево зависимостей процесса. Это может быть полезно для отслеживания приложения-источника, например zombie/defunct процессов (можно отследить и по ps -ef).

Аналог ps из мира Windows Powershell – довольно удобно с pipe:sort, select на основе столбцов в выводе.

Мониторинг всей системы

top/htop – мониторинг системных ресурсов и процессов в Linux. Показывает сводку по всей системе (сводка из команды uptime:uptime, user count, load average; tasks, CPU usage, Mem usage) и те процессы, которые потребляют больше всего ресурсов. Для начала в общем случае смотрится загрузка CPU/MEM, затем остальное.

load average – безразмерная метрика, показывает среднюю загрузку системы за период времени (100% значения =

60% загрузка за 1/5/15 минутный интервалы +

40% загрузка со старта системы – подробнее ниже). По умолчанию загрузка считается нулевой, каждый процесс, который ждет своей очереди для обработки CPU или Drive (HDD/SSD) добавляет значение в 1 к load average, каждый процесс, который прерывается, наоборот, уменьшает значение на 1. Сама метрика получается из файла /proc/loadavg.

Чтобы получить понимание загружена ли система по load average, значение load average нужно поделить на количество CPU (ядер CPU). Конечно это далеко не всегда справедливо, потому что только в идеальных условиях, процессоры/ядра загружаются равномерно.

В результате Load average в значении 1.73 говорит о разном:

• на системе c 8 CPU – система “отдыхает”
• на в системе с 2 CPU – система недозагружена на 0.27%
• на в системе с 1 CPU – система в полке на 0.73%

В примере ниже с реальных серверов – сервер с 2 CPU очень нагружен (6.43/2), а сервера с 8 (3.65/8) и 16 (0.03/16) недозагружены.

С точки зрения математики значение load average состоит из:

• 63% от значения берется из предыдущего минуты/5минут/15 минут
• 37% берется от загрузки с начала старта системы

На практике сталкивался с высоким load average на gentoo после нагрузки на cpu/HDD (сжатие/архивирование файлов, системное обновление), причем load average уже после самой причины загрузки “не уходил” в течении

часа – видимо это шлейф 37%.

lsof – показать открытые процессами файлами. Сопоставление какой файл открыт каким процессом. Может быть полезно при размонтировке носителей (напр. ошибка “device or resource busy” при попытке eject USB). Чтобы посмотреть все процессы нужно запускать из под sudo.

Изменение

kill (в Windows taskmanager ctrl-shift-esc, taskkill, process explorer can restart/pause processes) – позволяет остановить (частный случай для Linux kill) процесс/процессы по ID процесса (PID), процессы определенного пользователя и проч.

kill позволяет отсылать большое количество сигналов процессам. По умолчанию используется непринудительная остановка процесса kill -15 (sigterm), которая позволяет приложению высвободить ресурсы и приостановить отключение, в случае если оно считает что оно опасно (например, для сохранения файлов или просто прописан exception не умирать никогда). kill -l позволяет показать все возможные сигналы, которые можно отослать процессу (64 штуки!).

nice – позволяет запускать приложения с измененным приоритетом nice value. Например, долгие неважные процессы (backup, обновление системы/приложений, скан сети) можно сделать с nice 15-20, а важные с -15 – -20.

Источник

Изучаем процессы в Linux. Управление процессами

Обновл. 12 Июл 2021 |

Процесс — это экземпляр запущенной программы. Всякий раз, когда в терминале выполняется какая-нибудь команда (например, команда pwd ), система создает/запускает новый процесс.

Типы процессов

В Linux существует три основных типа процессов:

Процессы переднего плана (или «интерактивные процессы») — они инициализируются и управляются с помощью терминального сеанса. Другими словами, необходимым условием для запуска таких процессов является наличие пользователя, подключенного к системе; они не запускаются автоматически как часть системных функций/служб. Когда команда/процесс выполняется на переднем плане, то они полностью занимают запустивший их терминал. Вы не сможете использовать другие команды, т.к. приглашение оболочки будет недоступно, пока данный процесс выполняется на переднем плане.

Фоновые процессы (или «автоматические процессы») — это процессы, не подключенные к терминалу; они не ожидают пользовательского ввода данных. Таким образом, другие процессы могут выполняться параллельно с процессом, запущенным в фоновом режиме, поскольку им не нужно ждать его завершения.

Демоны (англ. «daemons») — это особый тип фоновых процессов, которые запускаются при старте системы и продолжают работать в виде службы; они не умирают. Такие процессы запускаются как системные задачи (службы). Однако при этом они могут управляться пользователем через init-процесс (о котором мы поговорим чуть позже). Например, к демонам относится служба электронных сообщений sendmail и sshd — служба, принимающая от клиентов запросы на соединения по протоколу ssh. За исключением процесса init и некоторых других, процессы демонов обычно имеют окончание d в своем имени.

Как Linux идентифицирует процессы?

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

Процессы запущенной программы имеют уникальный пятизначный номер — PID (сокр. от «Process IDentificator» — «идентификатор процесса»), а также PPID (сокр. от «Parent Process IDentificator» — «идентификатор родительского процесса»). В связи с этим процессы дополнительно разделяют на две группы:

Родительские процессы — это процессы, которые во время своего выполнения создают другие процессы.

Дочерние процессы — эти процессы, создаваемые другими процессами во время своего выполнения.

Прародителем всех процессов в системе является процесс init (от англ. «initialization») — первая программа, которая выполняется при загрузке Linux и управляет всеми другими процессами в системе. init запускается самим ядром и всегда имеет PID = 1, поэтому у него в принципе нет родительского процесса.

Примечание: В любой момент времени в системе не существует двух процессов с одинаковым PID. Вновь создаваемому процессу может быть назначен ранее использованный свободный PID.

Состояния процесса в Linux

Когда процесс передает ядру запрос, который не может быть исполнен сразу же, то процесс «погружается в сон/ожидание» и «пробуждается», когда запрос может быть удовлетворен. В связи с этим, в зависимости от текущей ситуации, процесс, во время своего выполнения, может переходить из одного состояния в другое:

Рассмотрим основные состояния процесса:

Выполнение — процесс либо запущен (текущий процесс в системе), либо готов к запуску (ожидает передачи на выполнение процессору).

Ожидание — процесс ожидает наступления некоторого события (пользовательского ввода, сигнала от другого процесса и т.п.) или выделения системных ресурсов. Кроме того, ядро также различает два типа ожидающих процессов:

прерываемые ожидающие процессы — могут быть прерваны сигналами;

непрерываемые ожидающие процессы — процессы ожидают непосредственно на аппаратном уровне и не могут быть прерваны каким-либо событием/сигналом.

Завершен — процесс был остановлен, как правило, путем получения сигнала штатного завершения работы exit().

Зомби — иногда, когда родительский процесс убивается до завершения дочернего процесса, дочерние процессы становятся «осиротевшими», при этом в качестве нового родителя (с соответствующим изменением PPID) им назначается процесс init. Убитые процессы, но при этом все еще отображающиеся в таблице процессов, называются процессами зомби (они мертвы и не используются).

Как получить идентификатор (PID) процесса

Для отображения идентификатора нужного вам процесса можно использовать команду pidof, например:

$ pidof init
$ pidof bash
$ pidof systemd

Примечание: На вышеприведенном скриншоте вы можете видеть, что процессу init назначен PID=1 , а процессу systemd — PID=881 , хотя системой инициализации в Debian является именно systemd. Детально о том, почему возникла такая путаница, читайте здесь.

Чтобы вывести PID и PPID текущей оболочки, выполните:

$ echo $$
$ echo $PPID

Запуск интерактивного процесса в Linux

Как только вы выполните какую-нибудь команду или программу (например, firefox ), она создаст в системе соответствующий процесс. Вы можете запустить процесс переднего плана (он будет подключен к терминалу, ожидая пользовательского ввода) следующим образом:

Запуск фонового процесса в Linux

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

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

Чтобы запустить процесс в фоновом режиме, используйте символ & после имени запускаемой программы. В этом случае процесс не будет принимать пользовательский ввод, пока не переместится на передний план:

Вы также можете отправить процесс в фоновый режим, приостановив его с помощью сочетания клавиш Ctrl+Z. Данное сочетание клавиш отправит процессу сигнал SIGSTOP , тем самым переведя его в режим ожидания:

$ firefox #После Enter нажмите Ctrl+Z
$ jobs

Чтобы продолжить выполнение вышеупомянутой приостановленной команды в фоновом режиме, используйте команду bg (от англ. «begin»):

Чтобы отправить фоновый процесс на передний план, используйте команду fg (от англ. «foreground») вместе с идентификатором задания следующим образом:

Отслеживание активных процессов

Существует несколько различных инструментов для просмотра/перечисления запущенных в системе процессов. Двумя традиционными и хорошо известными из них являются команды ps и top:

Команда ps

Отображает информацию об активных процессах в системе, как показано на следующем скриншоте:

$ ps
$ ps -e | head #(head – фильтр, отображающий только первые 10 строк вывода команды «ps -e»)

Для получения дополнительной информации о процессах, запущенных текущим пользователем, применяется опция -f :

Столбцы, присутствующие в выводе команды ps , имеют следующие значения:

UID — идентификатор пользователя, которому принадлежит процесс (тот, от чьего имени происходит выполнение).

PID — идентификатор процесса.

PPID — идентификатор родительского процесса.

C — загрузка CPU процессом.

STIME — время начала выполнения процесса.

TTY — тип терминала, связанного с процессом.

TIME — количество процессорного времени, потраченного на выполнение процесса.

CMD — команда, запустившая этот процесс.

Также можно отобразить информацию по конкретному процессу, используя команду ps -f [PID] , например:

Есть и другие опции, которые можно использовать вместе с командой ps :

-a — показывает информацию о процессах по всем пользователям;

-x — показывает информацию о процессах без терминалов;

-u — показывает дополнительную информацию о процессе по заданному UID или имени пользователя;

-e — отображение расширенной информации.

Если вы хотите вывести вообще всю информацию по всем процессам системы, то используйте команду ps –aux :

Обратите внимание на выделенный заголовок. Команда ps поддерживает функцию сортировки процессов по соответствующим столбцам. Например, чтобы отсортировать список процессов по потреблению ресурсов процессора (в порядке возрастания), введите команду:

$ ps -aux —sort=%cpu

Если вы ходите выполнить сортировку по потреблению памяти (в порядке убывания), то добавьте к имени интересующего столбца знак минуса:

$ ps -aux —sort=-%mem

Еще один очень популярный пример использования команды ps — это объединение её и команды grep для поиска заданного процесса по его имени:

$ ps -aux | grep bash

Команда top

Команда top отображает информацию о запущенных процессах в режиме реального времени:

PID — идентификатор процесса.

USER — пользователь, которому принадлежит процесс.

PR — приоритет процесса на уровне ядра.

NI — приоритет выполнения процесса от -20 до 19 .

VIRT — общий объем (в килобайтах) виртуальной памяти (физическая память самого процесса; загруженные с диска файлы библиотек; память, совместно используемая с другими процессами и т.п.), используемой задачей в данный момент.

RES — текущий объем (в килобайтах) физической памяти процесса.

SHR — объем совместно используемой с другими процессами памяти.

S (сокр. от «STATUS») — состояние процесса:

S (сокр. от «Sleeping») — прерываемое ожидание. Процесс ждет наступления события.

I (сокр. от «Idle») — процесс бездействует.

R (сокр. от «Running») — процесс выполняется (или поставлен в очередь на выполнение).

Z (сокр. от «Zombie») — зомби-процесс.

%CPU — процент используемых ресурсов процессора.

%MEM — процент используемой памяти.

TIME+ — количество процессорного времени, потраченного на выполнение процесса.

COMMAND — имя процесса (команды).

Также в сочетании с основными символами состояния процесса (S от «STATUS») вы можете встретить и дополнительные:

— процесс с высоким приоритетом;

N — процесс с низким приоритетом;

l — многопоточный процесс;

s — лидер сессии.

Примечание: Все процессы объединены в сессии. Процессы, принадлежащие к одной сессии, определяются общим идентификатором сессии — идентификатором процесса, который создал эту сессию. Лидер сессии — это процесс, идентификатор сессии которого совпадает с его идентификаторами процесса и группы процессов.

Команда glances

Команда glances — это относительно новый инструмент мониторинга системы с расширенными функциями:

Примечание: Если в вашей системе отсутствует данная утилита, то установить её можно с помощью следующих команд:

$ yum install -y glances

$ sudo apt-get update
$ sudo apt-get install glances

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

Также в Linux присутствуют некоторые команды для управления процессами:

kill — посылает процессу сигнал завершения работы;

pkill — завершает процесс по его имени;

pgrep — ищет процесс по его имени (и, опционально, по имени запустившего его пользователя);

killall — завершает все активные процессы.

Ниже приведены несколько основных примеров их использования:

$ pgrep -u diego firefox
$ kill 6516
$ pgrep -u diego firefox
$ pgrep -u diego glances
$ pkill glances
$ pgrep -u diego glances

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

Основополагающим способом управления процессами в Linux является отправка им соответствующих сигналов. Для перечисления списка всех доступных сигналов, введите команду:

Чтобы отправить процессу нужный сигнал, используйте команды kill , pkill или pgrep , о которых мы упоминали ранее. Но программы могут реагировать на сигналы только в том случае, если они запрограммированы на распознавание этих сигналов.

Большинство сигналов предназначены для внутреннего использования системой или для программистов, когда они пишут код. Ниже приведены наиболее полезные сигналы:

SIGHUP (1) — отправляется процессу, когда его управляющий терминал закрыт.

SIGINT (2) — отправляется процессу управляющим терминалом, когда пользователь прерывает процесс нажатием клавиш Ctrl+C.

SIGQUIT (3) — отправляется процессу, если пользователь посылает сигнал выхода Ctrl+D.

SIGKILL (9) — этот сигнал немедленно завершает (убивает) процесс, и процесс не будет выполнять никаких операций очистки за собой.

SIGTERM (15) — сигнал завершения программы (отправляется командой kill по умолчанию).

SIGTSTP (20) — отправляется процессу управляющим терминалом с запросом на остановку; инициируется пользователем нажатием клавиш Ctrl+Z.

Ниже приведены примеры команды kill для уничтожения приложения firefox с помощью PID, после его зависания:

$ pgrep -u diego firefox
2275 #ответ терминала
$ kill 9 2275

$ kill -SIGKILL 2275

Чтобы убить приложение, используя его имя, применяются команды pkill или killall , например:

Изменение приоритета процесса

В системе Linux все активные процессы имеют определенный приоритет выполнения, задаваемый так называемым nice-значением. Процессы с более высоким приоритетом обычно получают больше процессорного времени, чем процессы с более низким приоритетом. Однако пользователь с root-правами может повлиять на это с помощью команд nice и renice.

Узнать значение приоритета команды можно по выводу команды top (столбец NI):

Используйте команду nice , чтобы задать NI-значение для запускаемого процесса. Имейте в виду, что обычные пользователи могут задавать данный параметр в диапазоне от 0 до 20 тем процессам, которыми они владеют. Только пользователь root может использовать отрицательные значения приоритета.

Чем больше nice-значение, тем меньшим приоритетом будет обладать процесс. Например, вы можете задать приоритет для запускаемого процесса следующим образом:

$ nice -n 10 firefox

Чтобы изменить приоритет уже запущенного процесса, используйте команду renice следующим образом:

$ renice +8 5547
$ renice +8 1151

На данный момент это всё! Если у вас есть какие-либо вопросы или дополнительные идеи, вы можете поделиться ими с нами с помощью комментариев.

Поделиться в социальных сетях:

В чем разница между su и sudo в Linux?

Комментариев: 1

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

Добавить комментарий Отменить ответ

• Словарь программиста
• Урок №1. Введение в программирование
• Что делать после установки Windows?
• 70+ бесплатных ресурсов для изучения программирования
• Создание игры «Тетрис»
• Создание игры «Змейка»
• Создание игры «Сапер»
• Cоздание игры «Breakout»
• Что такое Linux?
• Сравнение Linux и Windows

Источник