Как посмотреть список процессов в linux

14. Процессы №1: Информация о процессах №1

Как мы уже выяснили, программы хранятся в файловой системе на накопителе – т.е. жёстком диске или ssd. Когда мы запускаем программу, она загружается в оперативную память, так как скорость чтения с жёсткого диска или даже ssd относительно низкая, а процессор работает на больших скоростях. Как правило, большие программы загружаются в оперативную память не полностью, а по мере необходимости. При этом, для каждой программы создаётся иллюзия, что она – единственная в оперативной памяти, то есть для неё создаётся так называемая «виртуальная память». Также программы при запуске загружают какие-то файлы, будь то файлы настроек или пользовательские файлы – как например, если мы запускаем nano file, то в память загружаются как сам /usr/bin/nano, его настройки — /etc/nanorc и ~/.nanorc, всякие библиотеки, необходимые для работы nano и сам файл, который мы открываем. Кроме этого также запускаемой программе передаются переменные окружения и ещё много всего. Ну и находясь в оперативке, эта программа делает какие-то вычисления с помощью центрального процессора, обрабатывает данные и сохраняет на диске. И совокупность всего этого называется процессом.

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

И так, выполняемая программа – это процесс. Начнём с того, что администратору важно видеть список процессов. Для этого есть несколько способов, начнём с утилиты ps. Если просто запустить:

мы увидим список процессов, запущенных в этом терминале. Как вы заметили, вывелось 2 строчки – bash и ps. При том, что ps у нас выполнился за какие-то доли секунды, он у нас всё равно виден в выводе – потому что он делает эдакий скриншот процессов именно в момент выполнения, поэтому и видит сам себя.

Вообще, ps работает с 3 видами ключей: юниксовыми – они обычно начинаются на один дефис (-), BSD-шные – вовсе без дефиса и GNU-шные – как правило это слова, поэтому, чтобы не счесть их за комбинацию букв, используется два дефиса. Если посмотреть документацию:

man ps

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

ps -ef

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

Как видите, вывод у ps довольно большой и не помещается на экране, поэтому урезается сбоку. Чтобы мы могли нормально прочесть, мы можем передать вывод ps команде less. Правда по умолчанию less переносит текст на новые строки, из-за чего сбиваются столбцы, поэтому less лучше использовать с ключом -S, который не переносит строки. В итоге:

ps -ef | less -S

Давайте разберём, что означают ключи и как читать вывод. Ключ -e выводит все процессы всех пользователей:

ps -e

Да, процессы запускаются от имени пользователей. От этого зависит какие права будут у процесса. Допустим, если я запускаю программу nano от пользователя user, то программа сможет работать с моими файлами. А ключ f:

ps -f

показывает чуть больше информации о процессе. Давайте пройдёмся по столбикам:

ps -ef | less -S

Первое – UID – user id — пользователь, который запустил процесс. Большинство процессов в системе запущены от пользователя root – его также называют суперпользователем – это юзер, у которого есть все права на систему. По возможности, люди стараются не использовать рута везде. Если у программы будет какой-то баг или уязвимость и если она запущена от рута, то программа может сильно навредить системе. Поэтому для программ, которые не требуют особых прав, обычно создают сервисных пользователей. Как правило при установке программы она сама всё это настраивает. Ну и наконец у нас тут есть программы, запущенные от нашего пользователя. Как видите, я вроде ничего кроме эмулятора терминала не запускал, а в системе уже пару сотен процессов.

Второй столбик – PID – process id – идентификатор процесса. Он уникальный для каждого процесса, но совпадает для потоков одного процесса. Когда программа завершается, она освобождает номер и через какое-то время другая программа может использовать этот номер. С помощью этих номеров мы можем управлять процессами.

Третий столбик – PPID – parent process id – идентификатор родительского процесса. Почти все процессы в системе были запущены каким-то другим процессом. Допустим, когда мы запускаем эмулятор терминала, а в нём nano – то родительским процессом для nano является bash, который запущен в этом эмуляторе терминала:

ps -ef | grep nano

Родительским процессом для этого bash:

ps -f ppid

является gnome — процесс рабочего окружения. Родительским процессом для него является systemd — первый процесс. О systemd мы ещё поговорим.

Четвёртый столбик – C – использование процессора данным процессом. Много где у нас нули, но давайте запустим какое-нибудь тяжёлое приложение, допустим, firefox, найдём этот процесс:

ps -ef | grep firefox | less -S

и увидим, что для него это значение отличается от нуля.

Дальше — TTY – от слова телетайп. На хабре есть неплохая статья, объясняющая разницу между телетайпом, консолью, терминалом и т.п. А ps в этом столбике говорит, с каким терминалом ассоциируется данный процесс. Обычно, процесс, запущенный системой и не требующий графики, вывода информации на экран, не связан ни с каким терминалом. Процессы, требующие графики, завязаны на каком-нибудь виртуальном терминале – о них мы говорили ранее. Можно заметить, что тут указано tty1 и tty2 – если нажать правый ctrl + f1 или ctrl+f2, можно увидеть, что именно здесь у нас запущен графический интерфейс. При переходе на ctrl+f3 и далее открывается виртуальный терминал. А для эмуляторов терминала здесь могут быть значения pts/0, pts/1, pts/2 и т.п.

Ещё одно поле – TIME – это сколько времени процессор потратил на работу с данным процессом. Вы можете заметить, что здесь сплошные нули – потому что большинство этих процессов не требуют и секунды процессорного времени. Но если немного поработать с тем же браузером, то это время будет расти:

ps -ef | grep firefox

Кстати, чтобы мне не приходилось постоянно запускать эту команду, я могу использовать команду watсh:

watch "ps -ef | grep firefox"

Эта команда будет каждые 2 секунды запускать указанную команду. И так мы видим, что параметр TIME для нашего браузера постоянно увеличивается.

Ну и последнее – CMD – это команда, которая запустила процесс. Некоторые значения в квадратных скобках – для таких процессов ps не смог найти аргументов – обычно это процессы самого ядра.

Ладно, с выводом ps разобрались. Теперь мы знаем, где найти информацию о процессах. Но, помните, я говорил, что в Unix подобных системах придерживаются идеи «Всё есть файл»? И даже процессы у нас представлены в виде файлов. Но хранить информацию о процессах на жёстком диске нецелесообразно – какие-то процессы существуют доли секунд, какие-то появляются и удаляются сотнями – жёсткий диск не подходит для такого. А вот в оперативной памяти информацию о процессах можно спокойно хранить и представлять в виде файлов. Но раз уж речь идёт о файлах, то нам нужна файловая система. И вот ядро действительно создаёт так называемую виртуальную файловую систему, которая существует только в оперативной памяти.

Вообще, этих виртуальных файловых систем несколько, они используются для разных задач, мы о них поговорим в другой раз. Сейчас нас интересует файловая система procfs. Она примонтирована в директорию /proc:

cd /proc ls

Если посмотреть содержимое этой директории, мы увидим кучу директорий и файлов. Директории вам ничего не напоминают? Именно, это номера процессов, т.е. pid-ы. Ядро операционной системы генерирует эту информацию налету, стоит нам посмотреть – мы увидим актуальную информацию.

В этой директории кроме директорий процессов есть много других файлов – допустим, version:

сat version

показывает нам информацию о версии ядра или uptime:

cat uptime

информацию о том, сколько секунд включена система. Ну в секундах непонятно, поэтому легче использовать утилиту uptime. Кстати, постарайтесь самостоятельно найти, что означает второе значение в файле /proc/uptime и напишите в комментариях так, чтобы было понятно всем.

Ну и давайте посмотрим, что же такого в директориях процессов. Найдём pid процесса, допустим того-же firefox:

ps -ef | grep firefox

и зайдём в эту директорию:

сd pid ls

Тут у нас тоже куча файлов, которые относятся к нашему процессу. Эти файлы нужны не столько для людей, сколько для программ.

Какие-то из этих файлов и мы можем прочесть. Например, cmdline:

cat cmdline

Тут отображена команда, которая запустила процесс. Или environ:

cat environ

те переменные, которые передались процессу при запуске. Или status:

cat status

Какие-то из этих строчек понятны, а какие-то без гугла не разберёшь. Знать всё это не нужно, но, со временем, углубляясь в теорию или сталкиваясь с какими-то проблемами, вы начнёте разбираться в этих файлах.

Команда Linux ps

Команда Linux ps позволяет вывести список текущих процессов на вашем сервере. Она считывает информацию из файлов виртуальной файловой системы /proc .

Просмотр процессов Linux командой ps с примерами

Утилита обычно используется вместе с командами grep , а также less или more . Они помогают отфильтровать довольно длинные выходные данные.

Содержание

Синтаксис
Опции
Примеры использования команды ps
- Без опций
- Все процессы
- Все процессы в полном формате
- Все, кроме лидеров сессии
- Лишь лидеры сессии
- Процессы, связанные лишь с этим терминалом
- Лишь запущенные процессы
- Определённый процесс по идентификатору
- Процессы, выполняемые определённым пользователем
- Вместе с grep, more, less
Синтаксис
```
ps [опции]
```
Опции

-A, -e Все процессы -a Все с tty, кроме лидеров сеансов a Все с tty, включая других пользователей -d Все, кроме лидеров сессий -N, —deselect Отменить выбор r Только запущенные процессы T Все процессы на этом терминале x Процессы без управления tty -C Имя команды -p, p, —pid Идентификатор процесса -U, —User Имя пользователя -f Полный формат

Примеры использования команды ps

Без опций

Запуск без опций:
```
oleg@mobile:~:$ ps PID TTY TIME CMD 661 pts/0 00:00:00 bash 100194 pts/0 00:00:00 ps
```
На выходе получим:

PID Уникальный идентификатор процесса TTY Тип терминала TIME Общее время использования процессором процессорного времени CMD Имя команды, запустившей процесс

Все процессы

Вывод всех запущенных процессов (опция -e ):
```
oleg@mobile:~:$ ps -e PID TTY TIME CMD 1 ? 00:00:01 systemd 2 ? 00:00:00 kthreadd 3 ? 00:00:00 rcu_gp 4 ? 00:00:00 rcu_par_gp 5 ? 00:00:00 netns 7 ? 00:00:00 kworker/0:0H-events_highpri 9 ? 00:00:00 kworker/0:1H-kblockd . 91237 ? 00:00:00 bash 91253 ? 00:00:35 geany 91348 pts/1 00:00:00 bash 97188 ? 00:00:13 chromium 97211 ? 00:00:04 chromium 97250 ? 00:00:00 chromium 97370 ? 00:00:00 kworker/u16:2-phy1 101879 ? 00:00:00 sleep 101880 pts/0 00:00:00 ps
```
Все процессы в полном формате

Вывод всех процессов в полном формате (опции -e и -f ):
```
oleg@mobile:~:$ ps -ef UID PID PPID C STIME TTY TIME CMD root 1 0 0 05:35 ? 00:00:01 /sbin/init root 2 0 0 05:35 ? 00:00:00 [kthreadd] root 3 2 0 05:35 ? 00:00:00 [rcu_gp] root 4 2 0 05:35 ? 00:00:00 [rcu_par_gp] root 5 2 0 05:35 ? 00:00:00 [netns] root 7 2 0 05:35 ? 00:00:00 [kworker/0:0H-events_highpri] root 9 2 0 05:35 ? 00:00:01 [kworker/0:1H-events_highpri] root 10 2 0 05:35 ? 00:00:00 [mm_percpu_wq] . root 151835 2 0 11:47 ? 00:00:01 [kworker/u16:3-events_unbound] oleg 152597 789 12 11:49 ? 00:00:59 /usr/lib/chromium/chromium --type=renderer --enable-crashpad --crashpad-handler-pid= root 152704 2 0 11:49 ? 00:00:00 [kworker/u16:4-phy0] oleg 154608 789 0 11:54 ? 00:00:00 /usr/lib/chromium/chromium --type=renderer --enable-crashpad --crashpad-handler-pid= root 155042 2 0 11:55 ? 00:00:00 [kworker/u16:1-phy0] oleg 155457 789 0 11:56 ? 00:00:00 /usr/lib/chromium/chromium --type=renderer --enable-crashpad --crashpad-handler-pid= oleg 155482 789 0 11:56 ? 00:00:00 /usr/lib/chromium/chromium --type=renderer --enable-crashpad --crashpad-handler-pid= oleg 155523 789 0 11:56 ? 00:00:00 /usr/lib/chromium/chromium --type=renderer --enable-crashpad --crashpad-handler-pid= oleg 155813 789 0 11:57 ? 00:00:00 /usr/lib/chromium/chromium --type=renderer --enable-crashpad --crashpad-handler-pid= oleg 156001 789 0 11:57 ? 00:00:00 /usr/lib/chromium/chromium --type=renderer --enable-crashpad --crashpad-handler-pid= oleg 156116 450 0 11:57 ? 00:00:00 sleep 2 oleg 156117 661 0 11:57 pts/0 00:00:00 ps -ef
```
Все, кроме лидеров сессии

Вывод всех процессов, кроме лидеров сессии (опция -d ):
```
oleg@mobile:~:$ ps -d PID TTY TIME CMD 2 ? 00:00:00 kthreadd 3 ? 00:00:00 rcu_gp 4 ? 00:00:00 rcu_par_gp 5 ? 00:00:00 netns 7 ? 00:00:00 kworker/0:0H-events_highpri 9 ? 00:00:00 kworker/0:1H-events_highpri 10 ? 00:00:00 mm_percpu_wq . 
```
Лидером сеанса является процесс, запускающий другие процессы.

Лишь лидеры сессии

Вывод лишь лидеров процесса (опции -d и -N ):
```
oleg@mobile:~:$ ps -d -N PID TTY TIME CMD 1 ? 00:00:01 systemd 201 ? 00:00:09 systemd-journal 213 ? 00:00:00 systemd-udevd 313 ? 00:00:00 mount.ntfs 314 ? 00:00:00 mount.ntfs 328 ? 00:00:00 systemd-timesyn 332 ? 00:00:00 crond 333 ? 00:00:02 dbus-daemon 334 ? 00:00:00 systemd-logind 344 ? 00:00:06 NetworkManager 345 ? 00:00:01 wpa_supplicant 351 ? 00:00:00 sshd 353 tty1 00:00:00 agetty 354 ? 00:00:00 slim 393 tty7 00:04:27 Xorg 440 ? 00:00:00 systemd 497 ? 00:00:00 dbus-daemon 498 ? 00:00:00 at-spi-bus-laun 510 ? 00:00:00 gvfsd 538 ? 00:00:00 polkitd 661 pts/0 00:00:00 bash 3819 ? 00:01:40 pulseaudio 3832 ? 00:00:00 rtkit-daemon 91348 pts/1 00:00:00 bash
```
Процессы, связанные лишь с этим терминалом

Вывод всех процессов, связанных лишь с этим терминалом (опция T ):
```
oleg@mobile:~:$ ps T PID TTY STAT TIME COMMAND 661 pts/0 Ss 0:00 /bin/bash 104996 pts/0 R+ 0:00 ps T
```
Лишь запущенные процессы

Вывод лишь запущенных процессов (опция r ):
```
oleg@mobile:~:$ ps r PID TTY STAT TIME COMMAND 106301 pts/0 R+ 0:00 ps r
```
Определённый процесс по идентификатору

Вывод определённого процесса по идентификатору (PID):
```
oleg@mobile:~:$ ps -p 91237 PID TTY TIME CMD 91237 ? 00:00:00 bash
```
Вывод нескольких определённых процессов:
```
oleg@mobile:~:$ ps -p "91237 91253" PID TTY TIME CMD 91237 ? 00:00:00 bash 91253 ? 00:00:56 geany
```
Идентификаторы заключаются в кавычки.

Можно перечислять идентификаторы через запятую. Кавычки в этом случае не нужны:
```
oleg@mobile:~:$ ps -p 91237,91253 PID TTY TIME CMD 91237 ? 00:00:00 bash 91253 ? 00:00:56 geany
```
Если вы не знаете идентификатора нужной команды, то поступите следующим образом:
```
oleg@mobile:~:$ ps -C geany PID TTY TIME CMD 91253 ? 00:01:01 geany
```
В данном случае мы выяснили то, что geany имеет идентификатор 91253 .

Процессы, выполняемые определённым пользователем

Вывод процессов, выполняемых пользователем oleg (опция U ):
```
oleg@mobile:~:$ ps U oleg PID TTY STAT TIME COMMAND 440 ? Ss 0:00 /usr/lib/systemd/systemd --user 441 ? S 0:00 (sd-pam) 447 ? S 0:02 dwm 450 ? S 0:16 /bin/bash -login /home/oleg/.xinitrc 451 ? Sl 0:08 sakura 454 ? Sl 6:32 /usr/lib/chromium/chromium --enable-crashpad . 111952 ? S 0:00 sleep 2 111953 pts/0 R+ 0:00 ps U oleg
```
Вместе с grep, more, less

Использование команд more или less позволяет выводить результаты постранично:
```
oleg@mobile:~:$ ps -ef | more UID PID PPID C STIME TTY TIME CMD root 1 0 0 05:35 ? 00:00:01 /sbin/init root 2 0 0 05:35 ? 00:00:00 [kthreadd] root 3 2 0 05:35 ? 00:00:00 [rcu_gp] . root 39 2 0 05:35 ? 00:00:00 [kblockd] root 40 2 0 05:35 ? 00:00:00 [blkcg_punt_bio] root 41 2 0 05:35 ? 00:00:01 [kworker/1:1H-kblockd] root 42 2 0 05:35 ? 00:00:00 [ata_sff] --Далее--
```
Использование команды grep позволяет фильтровать результаты:
```
oleg@mobile:~:$ ps -ef | grep php-fpm root 114345 1 0 10:15 ? 00:00:00 php-fpm: master process (/etc/php/php-fpm.conf) http 114359 114345 0 10:15 ? 00:00:00 php-fpm: pool www http 114360 114345 0 10:15 ? 00:00:00 php-fpm: pool www oleg 117257 661 0 10:22 pts/0 00:00:00 grep php-fpm
```
В данном случае были выведены лишь строки, содержащие php-fpm .

Заключение

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

Как посмотреть список процессов в linux

Всякая выполняющаяся в Linux программа называется процессом. Linux как многозадачная система характеризуется тем, что одновременно может выполняться множество процессов, принадлежащих одному или нескольким пользователям. Вывести список исполняющихся в текущее время процессов можно командой ps , например, следующим образом:
```
/home/larry# ps PID TT STAT TIME COMMAND 24 3 S 0:03 (bash) 161 3 R 0:00 ps /home/larry#
```
Обратите внимание, что по умолчанию команда ps выводит список только тех процессов, которые принадлежат запустившему её пользователю. Чтобы посмотреть все исполняющиеся в системе процессы, нужно подать команду ps -a . Номера процессов (process ID, или PID ), указанные в первой колонке, являются уникальными номерами, которые система присваивает каждому работающему процессу. Последняя колонка, озаглавленная COMMAND, указывает имя работающей команды. В данном случае в списке указаны процессы, которые запустил сам пользователь larry . В системе работает ещё много других процессов, их полный список можно просмотреть командой ps -aux . Однако среди команд, запущенных пользователем larry , есть только bash (командная оболочка для пользователя larry ) и сама команда ps . Видно, что оболочка bash работает одновременно с командой ps . Когда пользователь ввёл команду ps , оболочка bash начала её исполнять. После того, как команда ps закончила свою работу (таблица процессов выведена на экран), управление возвращается процессу bash . Тогда оболочка bash выводит на экран приглашение и ждёт новой команды.

Работающий процесс также называют заданием (job). Понятия процесс и задание являются взаимозаменяемыми. Однако, обычно процесс называют заданием, когда имеют ввиду управление заданием (job control). Управление заданием — это функция командной оболочки, которая предоставляет пользователю возможность переключаться между несколькими заданиями.

В большинстве случаев пользователи запускают только одно задание — это будет та команда, которую они ввели последней в командной оболочке. Однако многие командные оболочки (включая bash и tcsh ) имеют функции управления заданиями (job control), позволяющие запускать одновременно несколько команд или заданий (jobs) и, по мере надобности, переключаться между ними.

Управление заданиями может быть полезно, если, например, вы редактируете большой текстовый файл и хотите временно прервать редактирование, чтобы сделать какую-нибудь другую операцию. С помощью функций управления заданиями можно временно покинуть редактор, вернуться к приглашению командной оболочки и выполнить какие-либо другие действия. Когда они будут сделаны, можно вернуться обратно к работе с редактором и обнаружить его в том же состоянии, в котором он был покинут. У функций управления заданиями есть ещё много полезных применений.

Передний план и фоновый режим

Задания могут быть либо на переднем плане (foreground), либо фоновыми (background). На переднем плане в любой момент времени может быть только одно задание. Задание на переднем плане — это то задание, с которым вы взаимодействуете; оно получает ввод с клавиатуры и посылает вывод на экран (если, разумеется, вы не перенаправили ввод или вывод куда-либо ещё). Напротив, фоновые задания не получают ввода с терминала; как правило, такие задания не нуждаются во взаимодействии с пользователем.

Некоторые задания исполняются очень долго, и во время их работы не происходит ничего интересного. Пример таких заданий — компилирование программ, а также сжатие больших файлов. Нет никаких причин смотреть на экран и ждать, когда эти задания выполнятся. Такие задания следует запускать в фоновом режиме. В это время вы можете работать с другими программами.

Для управления выполнением процессов в Linux предусмотрен механизм передачи сигналов. Сигнал — это способность процессов обмениваться стандартными короткими сообщениями непосредственно с помощью системы. Сообщение-сигнал не содержит никакой информации, кроме номера сигнала (для удобства вместо номера можно использовать предопределённое системой имя). Для того, чтобы передать сигнал, процессу достаточно задействовать системный вызов kill() , а для того, чтобы принять сигнал, не нужно ничего. Если процессу нужно как-то по-особенному реагировать на сигнал, он может зарегистрировать обработчик, а если обработчика нет, за него отреагирует система. Как правило, это приводит к немедленному завершению процесса, получившего сигнал. Обработчик сигнала запускается асинхронно , немедленно после получения сигнала, что бы процесс в это время ни делал.

Два сигнала — номер 9 ( KILL ) и 19 ( STOP ) — всегда обрабатывает система. Первый из них нужен для того, чтобы убить процесс наверняка (отсюда и название). Сигнал STOP приостанавливает процесс: в таком состоянии процесс не удаляется из таблицы процессов, но и не выполняется до тех пор, пока не получит сигнал 18 ( CONT ) — после чего продолжит работу. В командной оболочке Linux сигнал STOP можно передать активному процессу с помощью управляющей последовательности Ctrl — Z .

Сигнал номер 15 ( TERM ) служит для прерывания работы задания. При прерывании (interrupt) задания процесс погибает. Прерывание заданий обычно осуществляется управляющей последовательностью Ctrl — C [1] . Восстановить прерванное задание никаким образом невозможно. Следует также знать, что некоторые программы перехватывают сигнал TERM (при помощи обработчика), так что нажатие комбинации клавиш Ctrl — C (о) может не прервать процесс немедленно. Это сделано для того, чтобы программа могла уничтожить следы своей работы прежде, чем она будет завершена. На практике, некоторые программы вообще нельзя прервать таким способом.

Перевод в фоновый режим и уничтожение заданий

Начнём с простого примера. Рассмотрим команду yes, которая на первый взгляд может показаться бесполезной. Эта команда посылает бесконечный поток строк, состоящих из символа y на стандартный вывод. Посмотрим, как работает эта команда:
```
/home/larry# yes y y y y y
```
Последовательность таких строк будет бесконечно продолжаться. Уничтожить этот процесс можно, отправив ему сигнал прерывания, т. е. нажав Ctrl — C . Поступим теперь иначе. Чтобы на экран не выводилась эта бесконечная последовательность перенаправим стандартный вывод команды yes на /dev/null . Как вы, возможно, знаете, устройство /dev/null действует как « чёрная дыра »: все данные, посланные в это устройство, пропадают. С помощью этого устройства очень удобно избавляться от слишком обильного вывода некоторых программ.
```
/home/larry# yes > /dev/null
```
Теперь на экран ничего не выводится. Однако и приглашение командной оболочки также не возвращается. Это происходит потому, что команда yes все ещё работает и посылает свои сообщения, состоящие из букв y на /dev/null . Уничтожить это задание также можно, отправив ему сигнал прерывания.

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

Один способ перевести процесс в фоновый режим — приписать символ & к концу команды. Пример:
```
/home/larry# yes > /dev/null & [1]+ 164 /home/larry#
```
Сообщение [1] представляет собой номер задания (job number) для процесса yes. Командная оболочка присваивает номер задания каждому исполняемому заданию. Поскольку yes является единственным исполняемым заданием, ему присваивается номер 1. Число 164 является идентификационным номером, соответствующим данному процессу ( PID ), и этот номер также дан процессу системой. Как мы увидим дальше, к процессу можно обращаться, указывая оба этих номера.

Итак, теперь у нас есть процесс команды yes, работающий в фоне, и непрерывно посылающий поток из букв y на устройство /dev/null . Для того, чтобы узнать статус этого процесса, нужно исполнить команду jobs , которая является внутренней командой оболочки.
```
/home/larry# jobs [1]+ Running yes >/dev/null & /home/larry#
```
Мы видим, что эта программа действительно работает. Для того, чтобы узнать статус задания, можно также воспользоваться командой ps , как это было показано выше.

Для того, чтобы передать процессу сигнал (чаще всего возникает потребность прервать работу задания) используется утилита kill . В качестве аргумента этой команде даётся либо номер задания, либо PID . Необязательный параметр — номер сигнала, который нужно отправить процессу. По умолчанию отправляется сигнал TERM . В рассмотренном выше случае номер задания был 1, так что команда kill %1 прервёт работу задания. Когда к заданию обращаются по его номеру (а не PID ), тогда перед этим номером в командной строке нужно поставить символ процента (« % »).

Теперь введём команду jobs снова, чтобы проверить результат предыдущего действия:
```
/home/larry# jobs [1] Terminated yes >/dev/null
```
Фактически задание уничтожено, и при вводе команды jobs следующий раз на экране о нем не будет никакой информации.

Уничтожить задание можно также, используя идентификационный номер процесса ( PID ). Этот номер, наряду с идентификационным номером задания, указывается во время старта задания. В нашем примере значение PID было 164, так что команда kill 164 была бы эквивалентна команде kill %1 . При использовании PID в качестве аргумента команды kill вводить символ « % » не требуется.

Приостановка и продолжение работы заданий

Запустим сначала процесс командой yes на переднем плане, как это делалось раньше:
```
/home/larry# yes > /dev/null
```
Как и ранее, поскольку процесс работает на переднем плане, приглашение командной оболочки на экран не возвращается.

Теперь вместо того, чтобы прервать задание комбинацией клавиш Ctrl — C , задание можно приостановить (suspend, буквально — подвесить ), отправив ему сигнал STOP . Для приостановки задания надо нажать соответствующую комбинацию клавиш, обычно это Ctrl — Z .
```
/home/larry# yes > /dev/null Ctrl-Z[1]+ Stopped yes >/dev/null /home/larry#
```
Приостановленный процесс попросту не выполняется. На него не тратятся вычислительные ресурсы процессора. Приостановленное задание можно запустить выполняться с той же точки, как будто бы оно и не было приостановлено.

Для возобновления выполнения задания на переднем плане можно использовать команду fg (от слова foreground — передний план).
```
/home/larry# fg yes >/dev/null
```
Командная оболочка ещё раз выведет на экран название команды, так что пользователь будет знать, какое именно задание он в данный момент запустил на переднем плане. Приостановим это задание ещё раз нажатием клавиш Ctrl — Z , но в этот раз запустим его в фоновый режим командой bg (от слова background — фон). Это приведёт к тому, что данный процесс будет работать так, как если бы при его запуске использовалась команда с символом & в конце (как это делалось в предыдущем разделе):
```
/home/larry# bg [1]+ yes $>$/dev/null & /home/larry#
```
При этом приглашение командной оболочки возвращается. Сейчас команда jobs должна показывать, что процесс yes действительно в данный момент работает; этот процесс можно уничтожить командой kill , как это делалось раньше.

Для того, чтобы приостановить задание, работающее в фоновом режиме, нельзя воспользоваться комбинацией клавиш Ctrl — Z . Прежде, чем приостанавливать задание, его нужно перевести на передний план командой fg и лишь потом приостановить. Таким образом, команду fg можно применять либо к приостановленным заданиям, либо к заданию, работающему в фоновом режиме.

Между заданиями в фоновом режиме и приостановленными заданиями есть большая разница. Приостановленное задание не работает — на него не тратятся вычислительные мощности процессора. Это задание не выполняет никаких действий. Приостановленное задание занимает некоторый объем оперативной памяти компьютера, через некоторое время ядро откачает эту часть памяти на жёсткий диск « до востребования ». Напротив, задание в фоновом режиме выполняется, использует память и совершает некоторые действия, которые, возможно, вам требуются, но вы в это время можете работать с другими программами.

Задания, работающие в фоновом режиме, могут пытаться выводить некоторый текст на экран. Это будет мешать работать над другими задачами.
```
/home/larry# yes &
```
Здесь стандартный вывод не был перенаправлен на устройство /dev/null , поэтому на экран будет выводится бесконечный поток символов y . Этот поток невозможно будет остановить, поскольку комбинация клавиш Ctrl — C не воздействует на задания в фоновом режиме. Для того чтобы остановить эту выдачу, надо использовать команду fg , которая переведёт задание на передний план, а затем уничтожить задание комбинацией клавиш Ctrl — C .

Сделаем ещё одно замечание. Обычно командой fg и командой bg воздействуют на те задания, которые были приостановлены последними (эти задания будут помечены символом + рядом с номером задания, если ввести команду jobs ). Если в одно и то же время работает одно или несколько заданий, задания можно помещать на передний план или в фоновый режим, задавая в качестве аргументов команды fg или команды bg их идентификационный номер (job ID). Например, команда fg %2 помещает задание номер 2 на передний план, а команда bg %3 помещает задание номер 3 в фоновый режим. Использовать PID в качестве аргументов команд fg и bg нельзя.

Более того, для перевода задания на передний план можно просто указать его номер. Так, команда %2 будет эквивалентна команде fg %2 .

Важно помнить, что функция управления заданием принадлежит оболочке. Команды fg , bg и jobs являются внутренними командами оболочки. Если, по некоторой причине, вы используете командную оболочку, которая не поддерживает функции управления заданиями, то вы в ней этих (и подобных) команд не отыщете.

[1] Прерывающая комбинация клавиш может быть установлена с помощью команды stty .

Работа с процессами в Linux. Как посмотреть список процессов? Как посмотреть список однотипных процессов?

Слово “процесс” само по себе понятно, но в этой статье рассмотрим этот термин со стороны администрирования серверов и управления процессами в Linux. Процесс — это набор взаимно последовательных событий/операций для выполнения той или иной задачи касательно работы на сервере. Не важно, просто мы подключаемся к серверу или же запускаем какое-то приложение, для осуществления всех этих процедур отвечают определенные запущенные процессы в системе.

Чтобы посмотреть какие процессы и кем запущены в текущее время на сервере, можно использовать очень полезную утилиту ps, которая выведет на экран список процессов.

PID (Proccess Identificator) – идентификатор процесса, который дает система для обозначения и различия процессов. Каждый процесс имеет свой уникальный идентификатор. По этому идентификатору Вы можете выполнять команды и находить информацию, которая касается только процесса с этим PID.

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

TIME – в этом поле указывается процессорное время, затраченное на выполнение процесса.

CMD – выводится название команды или же сервиса, которые запустили процесс.

Также утилиту ps используют в связке с различными ключами, для структурирования данных или получения дополнительной информации касаемо процессов.

На своей практике мы часто используем с утилиты ps такие ключи.
Ключ “а” для отображения всех процессов.

Ключ “ u ” фильтр по имени или идентификатору пользователя, который запустил процесс. Если после -u прописать имя пользователя, на экран будут выведены только процессы запущенные от этого пользователя.

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

На скриншоте выше можно видеть, что некоторые процессы указаны в квадратных скобках [ ] – это процессы, которые выполняют системные задачи и очень важны для ее работоспособности, поэтому не нужно выполнять никаких манипуляций с этими процессами. Все остальные процессы идут как обычные и являются пользовательскими, с ними уже можно работать.

Коротко пройдемся о том, что мы имеем на выводе в терминале после выполнения команды, для понимания что преподносит той или иной ключ.

Первый столбец USER – указывает пользователя с под которого был запущен процесс.

Дальше идет PID – аналогично этот параметр обозначает идентификатор процесса.

%CPU – затраченное процессорное время на процесс в процентном эквиваленте.

%MEM – затраченная оперативная память на процесс в процентном эквиваленте.

VSZ (Virtual Set Size) – виртуальный размер процесса в целом.

RSS (Resident Set Size ) – размер резидентного набора, размер процесса в текущое время.

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

В колонке STAT указывается статус процесса. Если кратко, статус определяет состояния процесса в данный момент. Основные статусы процессов:
- R (Running) – активный запущенный процесс, либо готов к выполнению.
- S (Sleeping) – спящий процесс, процесс находится состоянии ожидания, то есть ожидает какого-то события, сигнала либо же освобождения нужного ресурса.
- T – приостановленный процесс или трассируется отладчиком .
- Z (Zombie ) – убитый процесс, которого уже не существует, но соответствующие ему структуры ядра не освобождаются, это часто происходить когда родительский процесс завершился до получения сигнала о завершении от своего дочернего процесса.
- D (Direct) – находится в состоянии непрерывного ожидания дискового ввода/вывода.
Также эти состояния могут иметь дополнительный символы возле себя, которые добавляют к стандартным статусам некоторые особенности, например, часто можно встретить R+ или же Ss.
- знак + – указывает на приоритетность процесса.
- знак s – указывает, что это ведущий в сеансе процесс.
Соответственно если имеем статус Ss+ — это приоритетный ведущий процесс.

По столбцу START можно узнать время запуска процесса.

TIME – прописано процессорное время, затраченное на выполнение этого процесса.

И в конце идет графа COMMAND, где указано название команды или же сервиса, которые запустили процесс.

Ключ “f “ – для отображения дерева родительского и дочерних процессов.

Ключ “S” – суммирует информацию, такую как использование ЦП, время выполнения, из мёртвых (zombie) дочерних процессов в их родительские.

Ключ “r” – список процессов, которые находятся в статусе R (runnig, активные выполняющейся процессы).

Для сортировки процессов по нужному параметру как вариант использовать опцию sort, что дает возможность сортировать вывод процессов по любому полю. На примере мы сделали сортировки по индикатору процесса PID в порядке возрастания.

Если наоборот вы хотите отсортировать в порядке убывания, просто возле параметра сортировки добавьте знак -. Например, ps aux —sort=-%mem.

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

О процессах и о популярных командах top, kill мы также ранее упоминали в этой статье здесь .

Вывод списка процессов представляет общую картину происходящего в системе и дает проследить производительность сервера.

Команда ГиперХост всегда рада помочь своим клиентам решить вопросы касательно работы хостинга и не только. Мы администрируем все сервера наших клиентов 24/7.
Похожие публикации: