Linux
- 17.12.2018
- 27 592
- 5
- 23.11.2020
- 47
- 47
- 0
- Содержание статьи
- Что такое приоритет процесса?
- Как узнать приоритет процесса?
- С помощью команды top (все запущенные процессы)
- С помощью команды ps (конкретный процесс(ы) по его имени)
- С помощью команды ps (конкретный процесс по его PID)
- Задание приоритета при запуске процесса
- Изменение приоритета у существующего процесса
- Комментарии к статье ( 5 шт )
- Добавить комментарий
В некоторых ситуациях может возникнуть необходимость запускать скрипт/программу не со стандартным приоритетом, а с более высоким или низким, либо повысить или понизить приоритет у запущенного ранее процесса. В данной статье мы рассмотрим несколько способов, как можно это с делать.
Что такое приоритет процесса?
Приоритет процесса определяет, как часто именно этот процесс, по сравнению с другими запущенными процессами, стоящими в очереди на выполнение, будет исполняться процессором. В ОС Linux значение приоритета процесса варьируется в диапазоне значений от -20 до 19 (т.е. получается 40 возможных значений: -20, -19, -18 … 0, 1, 2 … 19) и называется niceness (сокращенно NI).
Чем меньше это значение, тем выше приоритет будет у такого процесса. Например, если у нас есть один процесс, работающий с приоритетом 10, а другой процесс работающий с приоритетом 15, то в первую очередь будет выполняться процесс приоритетом 10, а уже после него, тот, где приоритет 15. А в ситуации, когда есть 2 процесса и у одного из них приоритет будет равен -20, а у другого равен 10, то в первую очередь процессор будет обрабатывать тот процесс, у которого приоритет равен -20, а уже после тот, у которого приоритет равен 10.
Как узнать приоритет процесса?
С помощью команды top (все запущенные процессы)
Посмотреть приоритет процесса можно с помощью команды top
С помощью команды ps (конкретный процесс(ы) по его имени)
ps -o pid,comm,nice -C mysqld
PID COMMAND NI
706 mysqld 0С помощью команды ps (конкретный процесс по его PID)
ps -o pid,comm,nice 706
PID COMMAND NI
706 mysqld 0Задание приоритета при запуске процесса
Для того, чтобы задать приоритет при старте нового процесса, необходимо воспользоваться командой nice
nice -n [значение приоритета] [команда]
Запустить утилиту top с приоритетом 15:
nice -n 15 top
Изменение приоритета у существующего процесса
Для того, чтобы изменить приоритет у существующего процесса (т.е. такого процесса, который ранее был уже запущен), необходимо воспользоваться командой renice
renice [значение приоритета] -p [id процесса]
При понижении приоритета у процесса, который является вашим (т.е. запущен под той же учетной записью, под которой вы работаете в системе) — права суперпользователя не требуются, НО при повышении приоритета у процесса, требуется запускать команду renice с правами суперпользователя, т.е. с помощью sudo renice.
В противном случае, вы будете получать ошибку примерно такого содержания:
renice: failed to set priority for 91197 (process ID): Permission denied
sudo renice 0 -p 15483
15483 (process ID) old priority 15, new priority 0Мы изменили приоритет у существующего процесса (команда top из предыдущего примера) с 15 на 0.
В этом отрывке рассмотрены команды управления процессами. Вы научитесь замораживать процессы, размораживать, отправлять в фоновый режим, изменять приоритет, просматривать запущенные процессы и жестоко их убивать. Введено понятие сигналов. Рассмотрены такие команды, как bg, fg, jobs, kill, nohup, nice, renice, ps и top.
Навигация по основам Linux от основателя Gentoo:
Часть I
- BASH: основы навигации (вступление)
- Управление файлами и директориями
- Ссылки, а также удаление файлов и директорий
- Glob-подстановки (итоги и ссылки)
Часть II
- Регулярные выражения (вступление)
- Назначения папок, поиск файлов
- Управление процессами
- Обработка текста и перенаправления
- Модули ядра (итоги и ссылки)
Управление процессами
Запуск xeyes
Для изучения управления процессами, какой-нибудь процесс необходимо сначала запустить. Убедитесь, что у вас запущен X (графический сервер — прим. пер.) и выполните следующую команду:
$ xeyes -center red
Вы увидите всплывающее окошко xeyes и красные глаза, следящие за курсором мыши. Также, обратите внимание, что у вас не появилось приглашения для ввода команд в терминале.
Остановка процесса
Чтобы вернуть приглашение, вы должны нажать Control-C (часто пишется как Ctrl-C или ^C):
Вы получили назад свое приглашение, но и окно xeyes исчезло. Фактически, процесс был «убит». Вместо завершения по Control-C, мы можем просто остановить процесс с помощью Control-Z:
$ xeyes -center red
Control-Z
[1]+ Stopped xeyes -center red
$
На этот раз вы получите приглашение bash’a, а окно xeyes останется сверху. Если вы с ним немного поиграете, возможно заметите, что глаза заморожены на одном месте. Если окно xeyes будет перекрыто другим окном и затем снова открыто, вы увидите, что оно даже не перерисовалось. Процесс не делает ничего. Он на самом деле остановлен.
fg и bg
Чтобы процесс «растормошить» и запустить обратно, мы можем вывести его на передний план используя команду fg (от англ. foreground — прим. пер.):
$ fg
(test it out, then stop the process again)
Control-Z
[1]+ Stopped xeyes -center red
$
А теперь продолжим его в фоне с помощью команды bg (от англ. backgroud — прим. пер.):
$ bg
[1]+ xeyes -center red &
$
Прекрасно! Процесс xeyes сейчас запущен в фоновом режиме, а мы снова имеем приглашение bash.
Использование «&»
Если нам нужно сразу запустить xeyes в фоновом режиме (вместо использования Control-Z и bg), мы можем просто добавить «&» (амперсанд) в конец команды xeyes:
$ xeyes -center blue &
[2] 16224
Несколько фоновых процессов
Теперь в фоне у нас одновременно работают красные и синие xeyes. Мы можем просмотреть список заданий с помощью jobs:
$ jobs -l
[1]- 16217 Running xeyes -center red & [2]+ 16224 Running xeyes -center blue &
Число в левой колонке — это порядковый номер задания, который bash присваивает ему при запуске. Плюс (+) у второго задания значит, что это «текущее задание», оно будет выведено на передний план при вводе fg. Вы также можете вывести на передний план конкретное задание указывая его номер; например, fg 1 сделает таковым красный xeyes. Следующая колонка это идентификатор процесса или сокращенно pid, любезно добавленный в вывод благодаря опции -l. Наконец, состояние обоих процессов «Running» (выполняется) и их командная строка справа.
Введение в сигналы
Чтобы убить, остановить, или продолжить процесс, Linux использует специальную форму взаимодействия, называемую сигналы. Отправляя сигнал некоторому процессу, вы можете его завершить, остановить, или сделать что-нибудь еще. Это то, что происходит на самом деле, когда вы нажимаете Control-C, Control-Z, или используете bg и fg — вы указываете bash отправить процессу определенный сигнал. Сигналы также можно отправить с помощью команды kill указав ей как параметр id процесса (pid):
$ kill -s SIGSTOP 16224
$ jobs -l
[1]- 16217 Running xeyes -center red & [2]+ 16224 Stopped (signal) xeyes -center blue
Как можно заметить, kill не обязательно «убивает» процесс, хотя может и это. Используя опцию -s, kill может отправить процессу любой сигнал. Linux убивает, останавливает или продолжает процессы когда они получают SIGINT, SIGSTOP, или SIGCONT сигнал соответственно. Есть и другие сигналы, которые вы можете отправить процессам; некоторые сигналы могут обрабатываться внутри самих программ. Вы можете узнать о сигналах которые обрабатывает конкретная программа поискав в ее man’е секцию SIGNALS.
SIGTERM и SIGINT
Если вы хотите убить процесс, есть несколько вариантов. По-умолчанию, kill отправляет SIGTERM, который отличается от SIGINT отправляемого по Control-C, но обычно имеет тот же эффект:
$ kill 16217
$ jobs -l
[1]- 16217 Terminated xeyes -center red [2]+ 16224 Stopped (signal) xeyes -center blue
Полное убийство
Процесс может игнорировать оба сигнала, SIGTERM и SIGINT, либо по своему усмотрению, либо потому, что он остановлен, либо еще как-то «застрял». В этом случае, может быть необходимо использование большого молотка — сигнала SIGKILL. Процесс не может игнорировать SIGKILL:
$ kill 16224
$ jobs -l
[2]+ 16224 Stopped (signal) xeyes -center blue
$ kill -s SIGKILL 16224
$ jobs -l
[2]+ 16224 Interrupt xeyes -center blue
nohup
Терминал в котором вы запускаете задания, называется терминалом управления заданиями. Некоторые шеллы (но не bash по-умолчанию), отправляют сигнал SIGHUP фоновым заданиям когда вы выходите, заставляя их завершаться. Для защиты процессов от такого поведения, используйте nohup когда запускаете процесс:
$ nohup make &
[1] 15632
$ exit
Используем ps для вывода списка процессов
Команда jobs, которую мы использовали ранее выводит только те процессы, которые были запущены в вашей сессии bash. Чтобы увидеть все процессы в вашей системе, используйте ps совместно с опциями a и x:
$ ps ax
PID TTY STAT TIME COMMAND 1 ? S 0:04 init [3] 2 ? SW 0:11 [keventd] 3 ? SWN 0:13 [ksoftirqd_CPU0] 4 ? SW 2:33 [kswapd] 5 ? SW 0:00 [bdflush]
Здесь приведены только первые 5 процессов, поскольку обычно список процессов очень длинный. Команда дает вам «слепок» всего, что в данный момент выполняется на машине, однако в нем много лишней информации. Если бы вы, не указали ax, вы бы получили список только тех процессов, которые принадлежат вам, и которые есть в управляющем терминале. Команда ps x покажет все ваши процессы, даже те, которых нет в управляющем терминале. Если использовать ps a, то будет получен список процессов из терминалов всех пользователей.
Просмотр «леса» и «деревьев»
Вы также можете просмотреть и другую информацию о каждом процессе. Опция —forest позволяет легко просмотреть иерархию процессов и даст вам представление о том, как различные процессы в системе взаимосвязаны между собой. Если один процесс запускает другой процесс, то запущенный будет называться его потомком. В выводе —forest, родители находятся слева, а потомки появляются как ветки справа:
$ ps x --forest
PID TTY STAT TIME COMMAND 927 pts/1 S 0:00 bash 6690 pts/1 S 0:00 _ bash 26909 pts/1 R 0:00 _ ps x --forest 19930 pts/4 S 0:01 bash 25740 pts/4 S 0:04 _ vi processes.txt
«u» и «l» опции ps
Опции u и l могут быть использованы в любой комбинации с опциями a, x с целью получения более подробной информации о процессах:
$ ps au
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND agriffis 403 0.0 0.0 2484 72 tty1 S 2001 0:00 -bash chouser 404 0.0 0.0 2508 92 tty2 S 2001 0:00 -bash root 408 0.0 0.0 1308 248 tty6 S 2001 0:00 /sbin/agetty 3 agriffis 434 0.0 0.0 1008 4 tty1 S 2001 0:00 /bin/sh /usr/X chouser 927 0.0 0.0 2540 96 pts/1 S 2001 0:00 bash
$ ps al
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND 100 1001 403 1 9 0 2484 72 wait4 S tty1 0:00 -bash 100 1000 404 1 9 0 2508 92 wait4 S tty2 0:00 -bash 000 0 408 1 9 0 1308 248 read_c S tty6 0:00 /sbin/ag 000 1001 434 403 9 0 1008 4 wait4 S tty1 0:00 /bin/sh 000 1000 927 652 9 0 2540 96 wait4 S pts/1 0:00 bash
Использование top
Если вы обнаружили, что запускаете ps несколько раз подряд, пытаясь рассмотреть происходящие изменения, возможно вам стоит воспользоваться top. Программа top отображает постоянно обновляющийся список процессов, наряду с другой полезной информацией:
$ top
10:02pm up 19 days, 6:24, 8 users, load average: 0.04, 0.05, 0.00 75 processes: 74 sleeping, 1 running, 0 zombie, 0 stopped CPU states: 1.3% user, 2.5% system, 0.0% nice, 96.0% idle Mem: 256020K av, 226580K used, 29440K free, 0K shrd, 3804K buff Swap: 136544K av, 80256K used, 56288K free 101760K cached PID USER PRI NI SIZE RSS SHARE STAT LIB %CPU %MEM TIME COMMAND 628 root 16 0 213M 31M 2304 S 0 1.9 12.5 91:43 X 26934 chouser 17 0 1272 1272 1076 R 0 1.1 0.4 0:00 top 652 chouser 11 0 12016 8840 1604 S 0 0.5 3.4 3:52 gnome-termin 641 chouser 9 0 2936 2808 1416 S 0 0.1 1.0 2:13 sawfish
nice
Каждый процесс имеет свое значение приоритета, которое Linux использует для разделения времени CPU. Вы можете указать приоритет процесса при его запуске, с помощью команды nice:
$ nice -n 10 oggenc /tmp/song.wav
С тех пор, как приоритет стал называться nice, он стал легче для запоминания, так, большее значение nice делает «хорошо» (nice — хорошо, замечательно; прим. пер.) другим процессам, позволяя им получить более приоритетный доступ к времени CPU. По-умолчанию, процессы запускаются с приоритетом 0, поэтому установка приоритета в 10 для oggenc значит, что он будет давать больше времени поработать другим процессам. Как правило, это означает, что oggenc даст возможность другим процессам выполняться со своей обычной скоростью, не зависимо от того, сколько времени процессора хочет сам oggenc. Вы могли видеть эти «уровни любезности» в колонке NI у ps и top ранее.
renice
Команда nice может изменять приоритет процессов только во время их запуска. Если вам необходимо изменить приоритет работающего процесса, воспользуйтесь командой renice:
$ ps l 641
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND 000 1000 641 1 9 0 5876 2808 do_sel S ? 2:14 sawfish
$ renice 10 641
641: old priority 0, new priority 10
$ ps l 641
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND 000 1000 641 1 9 10 5876 2808 do_sel S ? 2:14 sawfish
Спасибо Dmitry Minsky (Dmitry.Minsky@gmail.com) за перевод.
Продолжение…
Об авторах
Daniel Robbins
Дэниэль Роббинс — основатель сообщества Gentoo и создатель операционной системы Gentoo Linux. Дэниэль проживает в Нью-Мехико со свой женой Мэри и двумя энергичными дочерьми. Он также основатель и глава Funtoo, написал множество технических статей для IBM developerWorks, Intel Developer Services и C/C++ Users Journal.
Chris Houser
Крис Хаусер был сторонником UNIX c 1994 года, когда присоединился к команде администраторов университета Тэйлора (Индиана, США), где получил степень бакалавра в компьютерных науках и математике. После он работал во множестве областей, включая веб-приложения, редактирование видео, драйвера для UNIX и криптографическую защиту. В настоящий момент работает в Sentry Data Systems. Крис также сделал вклад во множество свободных проектов, таких как Gentoo Linux и Clojure, стал соавтором книги The Joy of Clojure.
Aron Griffis
Эйрон Гриффис живет на территории Бостона, где провел последнее десятилетие работая в Hewlett-Packard над такими проектами, как сетевые UNIX-драйвера для Tru64, сертификация безопасности Linux, Xen и KVM виртуализация, и самое последнее — платформа HP ePrint. В свободное от программирования время Эйрон предпочитает размыщлять над проблемами программирования катаясь на своем велосипеде, жонглируя битами, или болея за бостонскую профессиональную бейсбольную команду «Красные Носки».
В статье я покажу вам как осуществляется управление процессами в Linux. Вы узнаете про сигналы, передний и задний фон, и приоритеты процессов.
Сигналы
Управление процессами в Linux – это довольно обширная темя. Но все сводится к одному, мы различными способами меняем характеристики процессов. При этом мы можем преследовать совершенно разные цели: например мы можем хотеть завершить или приостановить процесс, поменять ему приоритет, заставить работать в фоне и другое.
Управление процессами может происходить по разному. Начнём наше обучение с сигналов, которые мы можем отправлять процессам.
Сигналы нужны для асинхронного оповещения процессов о разнообразных событиях в системе. Это могут быть события оборудования или события других процессов. Работа сигналов очень похожа на прерывания. То есть, если процесс получает сигнал, то он прерывает свою обычную работу, обрабатывает сигнал, а затем продолжает работать.
Сигналы от ядра поступают процессам напрямую. А сигналы от одних процессов другим поступают через ядро, то есть с помощью системных вызовов. Системный вызов, который обрабатывает сигналы называется – kill(). Его так назвали, так как большинство стандартных сигналов завершают (убивают) процесс.
Посмотреть обзор на сигналы можно выполнив man 7 signal. Или вы можете почитать эту же документацию здесь.
Стандартные сигналы
В этой документации вы можете посмотреть список стандартных сигналов:
Разберём некоторые из низ:
- SIGHUP (1) – разрыв с управляющим терминалом. Процесс либо что-то предпримет (если программист об этом позаботился), либо завершится. Например, вы работаете с сервером, подключившись к нему по ssh, и вдруг связь пропадает, SSH сессия рвётся. Все ваши процессы неожиданно теряют управляющий терминал и начинают завершаться, так как получают от ядра этот сигнал.
- SIGINT (2) – клавиатурный сигнал, срабатывает когда мы нажимаем Ctrl+c. Это штатное завершение, то есть процесс будет завершён корректно (если процесс вообще умеет завершаться корректно).
- SIGQUIT (3) – клавиатурный сигнал, срабатывает когда мы нажимаем Ctrl+. Аварийное завершение с выдачей отладочной информации.
- SIGABRT (6) – аналог SIGQUIT (3). Если у процесса нет управляющего терминала, то отправить ему клавиатурный сигнал не получится, поэтому используется этот сигнал.
- SIGKILL (9) – этот сигнал сразу завершает процесс (некорректно). И это поведение нельзя изменить, то есть программист не может сам указать программе что делать в случае получения этого сигнала.
- SIGTERM (15) – это аналог SIGINT (2). Если у процесса нет управляющего терминала, то отправить ему клавиатурный сигнал не получится, поэтому используется этот сигнал.
- SIGTSTP (20) – клавиатурный сигнал, когда мы нажимаем Ctrl+z. Этот сигнал приостанавливает процесс на управляющем терминале и переводит процесс на задний фон. То есть процесс переходит в состояние T (stopped by job control signal — остановленный специальным сигналом).
Утилита kill
Существует специальная команда – kill, она позволяет отправлять сигналы процессам. Тип сигнала указывается в качестве параметра в виде номера (например, -9) или имени (например, -SIGKILL). Следующим параметром нужно указать PID процесса, которому мы отправляем сигнал. Вот примеры:
$ kill -9 9898 $ kill -SIGKILL 2565
Вы можете отправить сигнал своему процессу, а если хотите отправить сигнал чужому, то нужно использовать sudo, или запускать команду kill из под пользователя root.
Передний и задний фон
Когда вы работаете в графической системе, то вы можете одновременно работать в нескольких программах. Для этого используются окна приложений. Пока вы работаете с одной программой, её окошко работает на переднем фоне. А в это время другие окна могут оставаться на заднем фоне.
Управление процессами в Linux можно применять и для того, чтобы в терминале можно было работать также, на заднем и переднем фоне. Представьте, что вы читаете справку (man) и захотели что-то попробовать. Чтобы не закрывать man, вы можете нажать Ctrl+z и приостановить man. При этом работа man не просто приостанавливается, она уходит на задний фон.
alex@deb-11:~$ man 7 signal (тут я нажал Ctrl+z) [1]+ Остановлен man 7 signal
Дальше вы можете поработать в терминале. А затем, когда захотите, вернёте man на передний фон. А чтобы увидеть процессы на заднем фоне используется команда jobs:
alex@deb-11:~$ jobs [1]+ Остановлен man 7 signal
Разберём вывод: [1] – номер задания, + означает что это последнее приостановленное задание, а дальше идёт состояние и название процесса.
И наконец, чтобы вернуть задание на передний фон, нужно выполнить fg %<номер задания>. Или можно выполнить fg без указания номера задания, тогда на передний план вернётся задание, которое было помечено плюсиком в выводе jobs.
alex@deb-11:~$ fg %1
После выполнения последней команды, на передний план вернется работа man.
Группа переднего фона – это терминал и то что на нём сейчас выполняется. Все остальные группы – это группы заднего фона.
Работа процесса на заднем фоне
Выше я показал как остановить процесс и поместить его на задний фон. Но на заднем фоне процесс может быть не только в приостановленном состоянии. Если выполнение процесса не требует от вас каких-то интерактивных действий (никакого ввода или вывода), то можно заставить процесс выполнятся на заднем фоне. Для этого нужно выполнить bg %<номер задания>.
Например, начнём скачивание большого файла с помощью команды wget:
alex@deb-11:~$ wget https://releases.ubuntu.com/22.04.1/ubuntu-22.04.1-desktop-amd64.iso
Затем переведём процесс скачивания на задний фон, то-есть нажмём Ctrl+z. И посмотрим список заданий на заднем фоне:
alex@deb-11:~$ jobs [1]- Остановлен man 7 signal [2]+ Остановлен wget https://releases.ubuntu.com/22.04.1/ubuntu-22.04.1-desktop-amd64.iso
Теперь, с помощью команды bg, запустим процесс на заднем фоне:
alex@deb-11:~$ bg %2 [2]+ wget https://releases.ubuntu.com/22.04.1/ubuntu-22.04.1-desktop-amd64.iso & Вывод перенаправляется в «wget-log».
Wget должен выводить информацию о скачивании файла, но на заднем фоне запрещено выводить информацию на терминал. Именно поэтому весь вывод автоматически перенаправляется в файл – wget-log.
С помощью команды ls можем убедиться что файл скачивается (его размер увеличивается):
alex@deb-11:~$ ls -lh ubuntu-22.04.1-desktop-amd64.iso -rw-r--r-- 1 alex alex 435M сен 26 11:30 ubuntu-22.04.1-desktop-amd64.iso alex@deb-11:~$ ls -lh ubuntu-22.04.1-desktop-amd64.iso -rw-r--r-- 1 alex alex 956M сен 26 11:31 ubuntu-22.04.1-desktop-amd64.iso
Выше я уже писал, что запустить процесс на заднем фоне можно только, если он не интерактивный. Например запустить остановленный man не получится:
alex@deb-11:~$ jobs [1]+ Остановлен man 7 signal [2]- Запущен wget https://releases.ubuntu.com/22.04.1/ubuntu-22.04.1-desktop-amd64.iso & alex@deb-11:~$ bg %1 [1]+ man 7 signal & [1]+ Остановлен man 7 signal alex@deb-11:~$ jobs [1]+ Остановлен man 7 signal [2]- Запущен wget https://releases.ubuntu.com/22.04.1/ubuntu-22.04.1-desktop-amd64.iso &
Как только man попытался вывести на терминал справку, то сразу был опять остановлен. И остановлен он был тоже с помощью сигнала. Вот два сигнала, которые работают для фоновых заданий:
- SIGTTIN (21) – остановлен за попытку чтения из stdin (на заднем фоне).
- SIGTTOU(22) – остановлен за попытку вывода на stdout (на заднем фоне).
Если плохо помните стандартные потоки ввода вывода (stdin, stdout, stderr), то про них я писал здесь.
Изменение приоритета процесса
Приоритеты процессов Linux
В работающей системе Linux выполняется множество процессов. И каждому запущенному процессу назначается приоритет. Как ни странно, но чем больше значение приоритета, тем меньше сам приоритет. То есть, процесс с приоритетом 15 будет более приоритетным, чем процесс с приоритетом 20.
Более приоритетные процессы получают больше процессорного времени. Они более отзывчивы, выполняются более быстро. Но при этом, они сильнее нагружают процессор и замедляют все остальные процессы.
Но никакие пользователи и даже root не могут управлять приоритетами процессов. Они могут управлять другим значением – nice. Диапазон nice имеет 40 приоритетов от -20 до +19. По умолчанию, любой процесс Linux, созданный пользователем, имеет значение nice равное 0, и приоритет равный 20.
Вы можете увидеть значение nice для процессов своего пользователя и своего терминала с помощью следующей команды (утилиту ps я рассматривал здесь):
alex@deb-11:~$ ps -o pid,comm,nice,priority
PID COMMAND NI PRI
5564 bash 0 20
5761 ps 0 20
Или можно получить список всех процессов, а не только ваших:
alex@deb-11:~$ ps ax -o pid,comm,nice,priority
PID COMMAND NI PRI
1 systemd 0 20
2 kthreadd 0 20
3 rcu_gp -20 0
4 rcu_par_gp -20 0
6 kworker/0:0H-ev -20 0
****
Разница в том, что priority – это реальный приоритет процесса в данный момент, а nice – подсказка для ядра указывающая нужно ли увеличить или уменьшить приоритет процессу.
Для пользовательских процессов, в большинстве случаев, значение priority можно рассчитать по следующей формуле: priority = 20 + nice. Таким образом, процесс с nice=3 имеет priority=23, а процесс с nice=-7 имеет priority=13.
Кроме ps, для просмотра приоритетов процессов можно использовать top и htop.
В Linux управление процессами, а точнее их уровнем nice, происходит с помощью команд:
- nice – настраивает приоритет процесса перед его запуском;
- renice – позволяет изменить приоритет уже запущенного процесса.
При этом:
- обычный пользователь может лишь уменьшить nice своего процесса;
- root может уменьшить или увеличить nice своего или чужого процесса.
Команда nice
Вы можете легко проверить значение nice для своего терминала (или оболочки), выполнив команду nice без каких-либо аргументов:
alex@deb-11:~$ nice 0
То есть любые команды запущенные из этой оболочки будут иметь значение nice=0.
А чтобы запустить команду с изменённым значением nice, её нужно запускать таким образом: nice <приоритет> <выполняемая команда>. Например, запустим две программы с разным приоритетом (что-бы запустить их две в одном терминале, я использую выполнение на заднем фоне):
alex@deb-11:~$ nice -2 md5sum /dev/urandom ^Z [1]+ Остановлен nice -2 md5sum /dev/urandom alex@deb-11:~$ bg [1]+ nice -2 md5sum /dev/urandom & alex@deb-11:~$ nice -8 md5sum /dev/urandom ^Z [2]+ Остановлен nice -8 md5sum /dev/urandom alex@deb-11:~$ bg [2]+ nice -8 md5sum /dev/urandom & alex@deb-11:~$ jobs [1]- Запущен nice -2 md5sum /dev/urandom & [2]+ Запущен nice -8 md5sum /dev/urandom &
Теперь, с помощью htop, посмотрим на приоритеты процессов для нашего пользователя:
alex@deb-11:~$ htop -u alex
Как видите команды md5sum работают параллельно. Но у одной команды приоритет стал 22, а у другой 28. При этом более приоритетный процесс получает больше процессорного времени, это видно в колонке TIME+.
А если мы хотим указать отрицательное значение для nise. Другими словами, уменьшить nice и уменьшить priority, тем самым увеличив приоритет. То должны использовать двойное тире и sudo (так как обычный пользователь не имеет право запускать процессы с повышенным приоритетом):
alex@deb-11:~$ sudo nice --2 md5sum /dev/urandom [sudo] пароль для alex: ^Z [3]+ Остановлен sudo nice --2 md5sum /dev/urandom alex@deb-11:~$ bg [3]+ sudo nice --2 md5sum /dev/urandom & alex@deb-11:~$ jobs [1] Запущен nice -2 md5sum /dev/urandom & [2]- Запущен nice -8 md5sum /dev/urandom & [3]+ Запущен sudo nice --2 md5sum /dev/urandom &
Кстати, этот экземпляр md5sum, будет работать от пользователя root. Вот так можно посмотреть на все процессы md5sum с помощью ps:
alex@deb-11:~$ ps -C md5sum -o pid,user,comm,nice,priority,time,%cpu
PID USER COMMAND NI PRI TIME %CPU
5791 alex md5sum 2 22 00:13:35 90.6
5792 alex md5sum 8 28 00:09:31 64.3
5802 root md5sum -2 18 00:06:34 98.4
Выше видно, что сильнее всего нагружает процессор процесс с уровнем nice равным -2.
Команда renice
Чтобы изменить приоритет уже работающего процесса нужно использовать команду renice -n <значение> -p <pid>. И этой командой может пользоваться только root.
Вернём всем процессам значение nice=0:
alex@deb-11:~$ sudo renice -n 0 -p 5791
5791 (process ID) old priority 2, new priority 0
alex@deb-11:~$ sudo renice -n 0 -p 5792
5792 (process ID) old priority 8, new priority 0
alex@deb-11:~$ sudo renice -n 0 -p 5802
5802 (process ID) old priority -2, new priority 0
alex@deb-11:~$ ps -C md5sum -o pid,user,comm,nice,priority,time,%cpu
PID USER COMMAND NI PRI TIME %CPU
5791 alex md5sum 0 20 00:17:29 87.5
5792 alex md5sum 0 20 00:10:40 53.9
5802 root md5sum 0 20 00:11:28 98.3
А ещё вы можете изменить приоритет всех процессов определённого пользователя таким образом: sudo renice -n <значение nice> -u <имя пользователя>. Например:
alex@deb-11:~$ sudo renice -n 5 -u alex
1000 (user ID) old priority 0, new priority 5
alex@deb-11:~$ ps -C md5sum -o pid,user,comm,nice,priority,time,%cpu
PID USER COMMAND NI PRI TIME %CPU
5791 alex md5sum 5 25 00:18:47 85.7
5792 alex md5sum 5 25 00:11:58 55.1
5802 root md5sum 0 20 00:12:46 93.9
Обратите внимание, процессы alex стали с уровнем nice=5, а процесс root так и остался с уровнем nice=0.
Итог
Статья получилось довольно длинной. Я показал как происходит некоторое управление процессами в Linux.
Рассказал про сигналы и как их отправлять процессам с помощью клавиатуры или с помощью команды kill. Также я показал, как можно использовать передний (fg) и задний (bg) фон терминала, и этим реально можно пользоваться. Также я разобрал приоритеты процессов и как их можно менять с помощью команд nice и renice.
В статье много примеров использования команды ps. Думаю, что умение работать с этой утилитой, это очень полезный навык для системного администратора Linux.
Сводка
Имя статьи
Управление процессами Linux
Описание
В статье я покажу вам как осуществляется управление процессами в Linux. Вы узнаете про сигналы, передний и задний фон, и приоритеты процессов
Как вы думаете, операционная система Linux может автоматически позаботиться сама о себе? Когда работает все нормально или вам не нужны никакие нестандартные возможности — вполне да. Но иногда может понадобиться ваше вмешательство в ее работу.
В Linux для каждой отдельной программы, при ее запуске создается процесс. Неважно запускаете программу вы вручную самостоятельно или это делает система или ядро. Например, программа инициализации, которая запускается сразу после завершения загрузки ядра тоже имеет свой процесс с идентификатором 0. Процессы в linux можно описать как контейнеры, в которых хранится вся информация о состоянии и выполнении программы. Если программа работает хорошо, то все нормально, но если она зависла или вам нужно настроить ее работу может понадобиться управление процессами в Linux.
В этой статье будет затронута обширная тема, мы рассмотрим такие возможности:
- Просмотр запущенных процессов
- Просмотр информации о процессах
- Поиск процессов в Linux
- Изменение приоритета процессов
- Завершение процессов
- Ограничение памяти доступной процессу
Я не мог не включить в статью первые пункты, но они очень просты и мы не будем разбирать их очень подробно. Но вот все остальное может показаться сложным и недостаточно описанным.
Что такое процесс?
Начнем с того, что разберемся в терминах. По сути, процесс — это каждая программа. Как я уже говорил для каждой запускаемой программы создается отдельный процесс. В рамках процесса программе выделяется процессорное время, оперативная память и другие системные ресурсы. У каждого процесса есть свой идентификатор, Proccess ID или просто PID, по ним, чаще всего и определяются процессы Linux. PID определяется неслучайно, как я уже говорил, программа инициализации получает PID 1, а каждая следующая запущенная программа — на единицу больше. Таким образом PID пользовательских программ доходит уже до нескольких тысяч.
На самом деле, процессы Linux не настолько абстрактны, какими они вам сейчас кажутся. Их вполне можно попытаться пощупать. Откройте ваш файловый менеджер, перейдите в корневой каталог, затем откройте папку /proc. Видите здесь кучу номеров? Так вот это все — PID всех запущенных процессов. В каждой из этих папок находится вся информация о процессе.
Например, посмотрим папку процесса 1. В папке есть другие под каталоги и много файлов. Файл cmdline содержит информацию о команде запуска процесса:
cat /proc/1/cmdline
/usr/lib/systemd/systemd
Поскольку у меня используется система инициализации Systemd, то и первый процесс запускается для нее. С помощью каталога /proc можно сделать все. Но это очень неудобно, особенно учитывая количество запущенных процессов в системе. Поэтому для реализации нужных задач существуют специальные утилиты. Перейдем к рассмотрению утилит, которые позволяют реализовать управление процессами в Linux.
В Linux есть очень большое количество утилит для решения различных задач по управлению процессами. Это и такие многофункциональные решения, как htop, top, а также простые утилиты, например, ps, kill, killall, who и т д. Я не буду рассматривать в этой статье графические утилиты, и top тоже рассматривать не буду. Первое потому что слишком просто, второе — потому что htop лучше. Мы остановимся на работе с программой htop и ее аналогами в форме утилит в стиле GNU, одна утилита — одна функция.
Давайте установим htop, если она у вас еще не установлена. В Ubuntu это делается так:
sudo apt install htop
В других дистрибутивах вам нужно просто использовать свой менеджер пакетов. Имя пакета такое же.
Посмотреть запущенные процессы
Это очень простая задача, и также просто она решается. Для этого существует множество утилит, начиная от обычной ps, до более продвинутых интерактивных top, htop и так далее.
Открыв htop, мы сразу видим список запущенных процессов. Конечно, здесь отображены не все процессы linux, их-то в системе очень много, вы уже знаете, все они на один экран не поместятся. По умолчанию выводятся процессы, запущенные от имени вашего пользователя:
Вы можете увидеть такую информацию о процессе:
- PID — идентификатор процесса
- USER — пользователь, от которого был запущен процесс
- PRI — приоритет процесса linux на уровне ядра (обычно NI+20)
- NI — приоритет выполнения процесса от -20 до 19
- S — состояние процесса
- CPU — используемые ресурсы процессора
- MEM — использованная память
- TIME — время работы процесса
К отображению можно добавить и дополнительные параметры, но эти главные. Добавить параметры можно с помощью меню Setup. Там все очень просто, читайте подсказки и следуйте указаниям. Например, добавлен параметр PPID:
Очень важной особенностью программы есть то, что вы можете сортировать процессы в Linux по нужному параметру. Просто кликните по названию параметра, оно выделится зеленым и будет выполнена сортировка. Например, хотите посмотреть в каком порядке запускались процессы, сортируем по PID:
Также есть интересная возможность разместить процессы в виде дерева. Вы сможете увидеть, каким процессом был запущен тот или иной процесс. Для отображения дерева нажмите кнопку F5:
Почти те же действия вы можете выполнять с помощью программы ps. Только здесь нет такого удобного интерактивного режима. Все делается с помощью опций.
Рассмотрим основные опции, которые будем использовать:
- -e — вывести информацию обо всех процессах
- -a — вывести информацию обо всех наиболее часто запрашиваемых процессах
- -t — показывать только процессы из этого терминала
- -p — показывать информацию только об указанном процессе
- -u — показывать процессы только определенного пользователя
Одним словом, чтобы посмотреть все активные на данный момент процессы в linux, используется сочетание опций aux:
ps aux
Программа показывает все те же параметры, только здесь нет интерактивного интерфейса. Думаете здесь нельзя отсортировать процессы, но ошибаетесь, можно. Для этого есть опция sort. Вы можете сортировать их по любому полю, например:
ps aux --sort=%mem
Список будет отсортирован в обратном порядке, внизу значения больше, вверху — меньше. Если нужно в обратном порядке, добавьте минус:
ps aux --sort=-%cpu
В качестве поля для сортировки могут быть использованы приоритеты процессов Linux или любые другие параметры. Также вы можете обрезать вывод, если не нужно выводить всю информацию:
ps aux | tail
Казалось бы, у ps нет возможности стоить деревья процессов. Но не совсем, для этого существует отдельная команда:
pstree
Поиск процессов в Linux
Список процессов, это хорошо. Но иногда, когда какой-нибудь процесс завис и нужно убить процесс Linux или нам нужно провести с ним какие-либо действия, нужно выделить этот процесс из списка, узнать его PID и информацию о нем.
Чтобы найти процесс linux в htop можно использовать кнопку F3. Нажмите F3 и наберите нужное слово. Дальше чтобы перейти к следующему вхождению нажимайте F2 или Esc для завершения поиска:
Для поиска процессов в htop можно использовать также фильтр htop. Нажмите F4, введите слово и будут выведены только процессы linux, имя которых включает это слово.
В утилите ps фильтрации нет, но зато мы можем использовать утилиту grep, перенаправив вывод ps на нее чтобы найти процесс linux:
ps aux | grep chromium
Это очень часто употребляемая команда.
Изменение приоритета процессов
Приоритет процесса linux означает, насколько больше процессорного времени будет отдано этому процессу по сравнению с другими. Так мы можем очень тонко настроить какая программа будет работать быстрее, а какая медленнее. Значение приоритета может колебаться от 19 (минимальный приоритет) до -20 — максимальный приоритет процесса linux. Причем, уменьшать приоритет можно с правами обычного пользователя, но чтобы его увеличить нужны права суперпользователя.
В htop для управления приоритетом используется параметр Nice. Напомню, что Priv, это всего лишь поправка, она в большинстве случаев больше за Nice на 20. Чтобы изменить приоритет процесса просто установите на него курсор и нажимайте F7 для уменьшения числа (увеличения приоритета) или F8 — для увеличения числа.
Но и для решения этой задачи управления процессами Linux необязательно использовать htop. Вы можете сделать все и другими командами. Например, команда nice. С помощью нее вы можете указать приоритет для запускаемого процесса:
nice -n 10 apt-get upgrade
Или изменить приоритет для уже существующего по его pid:
renice -n 10 -p 1343
Завершение процессов в Linux
Если процесс завис и не отвечает, его необходимо завершить. В htop, чтобы убить процесс Linux, просто установите курсор на процесс и нажмите F9:
Система для управления процессами использует определенные сигналы, есть сигналы, которые указывают процессу завершиться. Вот несколько основных сигналов:
- SIGTERM — попросить процесс сохранить данные и завершится
- SIGKILL — завершить процесс немедленно, без сохранения
Вообще сигналов есть несколько десятков, но мы не будем их рассматривать. Отправим сигнал SIGKILL:
Также можно воспользоваться утилитой kill:
kill -TERM 1943
Также можно уничтожить процесс по имени:
killall chromium
Ограничение процессов
Управление процессами в Linux позволяет контролировать практически все. Вы уже видели что можно сделать, но можно еще больше. С помощью команды ulimit и конфигурационного файла /etc/security/limits.conf вы можете ограничить процессам доступ к системным ресурсам, таким как память, файлы и процессор. Например, вы можете ограничить память процесса Linux, количество файлов и т д.
Запись в файле имеет следующий вид:
<домен> <тип> <элемент> <значение>
- домен — имя пользователя, группы или UID
- тип — вид ограничений — soft или hard
- элемент — ресурс который будет ограничен
- значение — необходимый предел
Жесткие ограничения устанавливаются суперпользователем и не могут быть изменены обычными пользователями. Мягкие, soft ограничения могут меняться пользователями с помощью команды ulimit.
Рассмотрим основные ограничения, которые можно применить к процессам:
- nofile — максимальное количество открытых файлов
- as — максимальное количество оперативной памяти
- stack — максимальный размер стека
- cpu — максимальное процессорное время
- nproc — максимальное количество ядер процессора
- locks — количество заблокированных файлов
- nice — максимальный приоритет процесса
Например, ограничим процессорное время для процессов пользователя sergiy:
sergiy hard nproc 20
Посмотреть ограничения для определенного процесса вы можете в папке proc:
cat /proc/PID/limits
Max cpu time unlimited unlimited seconds
Max file size unlimited unlimited bytes
Max data size unlimited unlimited bytes
Max stack size 204800 unlimited bytes
Max core file size 0 unlimited bytes
Max resident set unlimited unlimited bytes
Max processes 23562 23562 processes
Max open files 1024 4096 files
Max locked memory 18446744073708503040 18446744073708503040 bytes
Max address space unlimited unlimited bytes
Max file locks unlimited unlimited locks
Max pending signals 23562 23562 signals
Max msgqueue size 819200 819200 bytes
Max nice priority 0 0
Max realtime priority 0 0
Max realtime timeout unlimited unlimited us
Ограничения, измененные, таким образом вступят в силу после перезагрузки. Но мы можем и устанавливать ограничения для текущего командного интерпретатора и создаваемых им процессов с помощью команды ulimit.
Вот опции команды:
- -S — мягкое ограничение
- -H — жесткое ограничение
- -a — вывести всю информацию
- -f — максимальный размер создаваемых файлов
- -n — максимальное количество открытых файлов
- -s — максимальный размер стека
- -t — максимальное количество процессорного времени
- -u — максимальное количество запущенных процессов
- -v — максимальный объем виртуальной памяти
Например, мы можем установить новое ограничение для количества открываемых файлов:
ulimit -Sn 1024
Теперь смотрим:
ulimit -Sn
Установим лимит оперативной памяти:
ulimit -Sv 500000
Напоминаю, что это ограничение будет актуально для всех программ, выполняемых в этом терминале.
Выводы
Вот и все. Теперь управление процессами в Linux не вызовет у вас проблем. Мы рассмотрели очень даже подробно эту тему. Если у вас остались вопросы или есть предложения по дополнению статьи, пишите в комментариях!
Статья распространяется под лицензией Creative Commons ShareAlike 4.0 при копировании материала ссылка на источник обязательна .
In this article, we’ll briefly explain the kernel scheduler (also known as the process scheduler), and process priority, which are topics beyond the scope of this guide. Then we will dive into a little bit of Linux process management: see how to run a program or command with modified priority and also change the priority of running Linux processes.
Read Also: How to Monitor Linux Processes and Set Process Limits on a Per-User Basis
Understanding the Linux Kernel Scheduler
A kernel scheduler is a unit of the kernel that determines the most suitable process out of all runnable processes to execute next; it allocates processor time between the runnable processes on a system. A runnable process is one which is waiting only for CPU time, it’s ready to be executed.
The scheduler forms the core of multitasking in Linux, using a priority-based scheduling algorithm to choose between the runnable processes in the system. It ranks processes based on the most deserving as well as the need for CPU time.
Understanding Process Priority and Nice Value
The kernel stores a great deal of information about processes including process priority which is simply the scheduling priority attached to a process. Processes with a higher priority will be executed before those with a lower priority, while processes with the same priority are scheduled one after the next, repeatedly.
There are a total of 140 priorities and two distinct priority ranges implemented in Linux. The first one is a nice value (niceness) which ranges from -20 (highest priority value) to 19 (lowest priority value) and the default is 0, this is what we will uncover in this guide. The other is the real-time priority, which ranges from 1 to 99 by default, then 100 to 139 are meant for user-space.
One important characteristic of Linux is dynamic priority-based scheduling, which allows the nice value of processes to be changed (increased or decreased) depending on your needs, as we’ll see later on.
How to Check Nice Value of Linux Processes
To see the nice values of processes, we can use utilities such as ps, top or htop.
To view processes nice value with ps command in user-defined format (here the NI the column shows the niceness of processes).
$ ps -eo pid,ppid,ni,comm
Alternatively, you can use top or htop utilities to view Linux processes nice values as shown.
$ top $ htop
Difference Between PR or PRI and NI
From the top and htop outputs above, you’ll notice that there is a column called PR and PRI receptively which shows the priority of a process.
This, therefore, means that:
NI– is the nice value, which is a user-space concept, whilePRorPRI– is the process’s actual priority, as seen by the Linux kernel.
How To Calculate PR or PRI Values
Total number of priorities = 140 Real time priority range(PR or PRI): 0 to 99 User space priority range: 100 to 139
Nice value range (NI): -20 to 19
PR = 20 + NI PR = 20 + (-20 to + 19) PR = 20 + -20 to 20 + 19 PR = 0 to 39 which is same as 100 to 139.
But if you see a rt rather than a number as shown in the screenshot below, it basically means the process is running under real-time scheduling priority.
How to Run A Command with a Given Nice Value in Linux
Here, we will look at how to prioritize the CPU usage of a program or command. If you have a very CPU-intensive program or task, but you also understand that it might take a long time to complete, you can set it a high or favorable priority using the nice command.
The syntax is as follows:
$ nice -n niceness-value [command args] OR $ nice -niceness-value [command args] #it’s confusing for negative values OR $ nice --adjustment=niceness-value [command args]
Important:
- If no value is provided, nice sets a priority of 10 by default.
- A command or program run without nice defaults to a priority of zero.
- Only root can run a command or program with increased or high priority.
- Normal users can only run a command or program with low priority.
For example, instead of starting a program or command with the default priority, you can start it with a specific priority using following nice command.
$ sudo nice -n 5 tar -czf backup.tar.gz ./Documents/* OR $ sudo nice --adjustment=5 tar -czf backup.tar.gz ./Documents/*
You can also use the third method which is a little confusing especially for negative niceness values.
$ sudo nice -5 tar -czf backup.tar.gz ./Documents/*
Change the Scheduling Priority of a Process in Linux
As we mentioned before, Linux allows dynamic priority-based scheduling. Therefore, if a program is already running, you can change its priority with the renice command in this form:
$ renice -n -12 -p 1055 $ renice -n -2 -u apache
From the sample top output below, the niceness of the teamspe+ with PID 1055 is now -12 and for all processes owned by user apache is -2.
Still using this output, you can see the formula PR = 20 + NI stands,
PR for ts3server = 20 + -12 = 8 PR for apache processes = 20 + -2 = 18
Any changes you make with renice command to a user’s processes nice values are only applicable until the next reboot. To set permanent default values, read the next section.
How To Set Default Nice Value Of a Specific User’s Processes
You can set the default nice value of a particular user or group in the /etc/security/limits.conf file. Its primary function is to define the resource limits for the users logged in via PAM.
The syntax for defining a limit for a user is as follows (and the possible values of the various columns are explained in the file):
#<domain> <type> <item> <value>
Now use the syntax below where hard – means enforcing hard links and soft means – enforcing the soft limits.
<username> <hard|soft> priority <nice value>
Alternatively, create a file under /etc/security/limits.d/ which overrides settings in the main file above, and these files are read in alphabetical order.
Start by creating the file /etc/security/limits.d/tecmint-priority.conf for user tecmint:
# vi /etc/security/limits.d/tecmint-priority.conf
Then add this configuration in it:
tecmint hard priority 10
Save and close the file. From now on, any process owned by tecmint will have a nice value of 10 and PR of 30.
For more information, read the man pages of nice and renice:
$ man nice $ man renice
You might also like to read these following articles about Linux process management.
- How to Find and Kill Running Processes in Linux
- A Guide to Kill, Pkill and Killall Commands to Terminate a Process in Linux
- How to Monitor System Usage, Outages and Troubleshoot Linux Servers
- CPUTool – Limit and Control CPU Utilization of Any Process in Linux
In this article, we briefly explained the kernel scheduler, process priority, looked at how to run a program or command with modified priority and also change the priority of active Linux processes. You can share any thoughts regarding this topic via the feedback form below.
If You Appreciate What We Do Here On TecMint, You Should Consider:
TecMint is the fastest growing and most trusted community site for any kind of Linux Articles, Guides and Books on the web. Millions of people visit TecMint! to search or browse the thousands of published articles available FREELY to all.
If you like what you are reading, please consider buying us a coffee ( or 2 ) as a token of appreciation.
We are thankful for your never ending support.