Invest-currency.ru

Как обезопасить себя в кризис?
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Вывод процессов linux

Список запущенных процессов Linux

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

Команды управления процессами

Чтобы увидеть список запущенных процессов, нужно ввести команду

В результате выполнения данной команды будет выведен список запущенных процессов Linux с указанием имени и PID (персональный идентификатор), используемого процессорного времени.

Ввод этой же команды с ключом

позволяет получить расширенную информацию о процессах: PID, использование оперативной памяти и процессора, имя пользователя запустившего процесс, команда запустившая процесс и время работы.

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

выводит информацию о состоянии процессов в текущий момент времени. Для отображения информации о списке запущенных процессов Linux в реальном времени используется команда

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

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

которая указывает, насколько приоритет нового процесса должен отличатся от приоритета процесс-родителя.

Значения аргумента команды nice от -20 до +19. Команда

изменяет приоритет запущенных процессов: renice -3522 -uuser– увеличение приоритета на 3 для процессов пользователя user и с идентификатором 522.

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

Для приостановки, завершения, запуска приостановленного процесса, а также для сообщения процессам другой информации, используются сигналы посылаемые процессам с помощью команды kill, например:

  • kill-9 688 – завершение процесса с PID688 в любом случае (сигнал kill);
  • kill -15 688 – завершение процесса с PID688 программно (сигнал term);
  • kill -19 688 – приостановка выполнения процесса с PID688 (сигнал stop).

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

«Зомби» в списке запущенных процессов Linux

Частенько в списке запущенных процессов Linux можно увидеть процессы-зомби (в графе статуса таких процессов стоит буква Z). Такие процессы образуются в том случае, если была вызвана команда завершения процесса, родитель которого еще не выполняется и которому может понадобиться обращение к данному процессу. Z-процесс не использует никакие ресурсы.

Просмотреть родителей процессов-зомби можно командой

Для того, чтобы убрать «зомби» из списка запущенных процессов Linux надо завершить родительский процесс.

Вывод процессов linux

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

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

Работающий процесс — в данный момент код процесса выполняется.

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

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

Каждому процессу в системе назначаются числовые идентификаторы (личные номера) в диапазоне от 1 до 65535 (PID — Process Identifier — идентификатор процесса) и идентификаторы родительского процесса (PPID — Parent Process Identifier — идентификатор родительского процесса). PID является именем процесса, по которому мы можем адресовать процесс в операционной системе при использовании различных средств просмотра и управления процессами. PPID определяет родственные отношения между процессами, которые в значительной степени определяют его свойства и возможности. Другие параметры, которые необходимы для работы программы, называют «окружение процесса». Одним из таких параметров является управляющий терминал — имя терминального устройства, на которое процесс выводит информацию и с которого информацию получает. Управляющий терминал имеют далеко не все процессы. Процессы, не привязанные к какому-то конкретному терминалу называются «демонами» (daemons). Такие процессы, будучи запущенными пользователем, не завершают свою работу по окончании сеанса, а продолжают работать, так как они не связаны никак с текущим сеансом и не могут быть автоматически завершены. Как правило, с помощью демонов реализуются серверные службы, так например сервер печати реализован процессом-демоном cupsd, а сервер журналирования — syslogd.

Для просмотра списка процессов в Linux существует команда ps. Формат команды следующий:

ps [PID] [options] — просмотр списка процессов. Без параметров ps показывает все процессы, которы были запущены в течение текущей сессии, за исключением демонов. Options может принимать одно из следующих значений или их комбинации:

-а или -e — показать все процессы

-f — полный листинг

-w — показать полные строки описания процессов. Если они превосходят
длину экрана, то перенести описание на следующую строку.

Это далеко не все параметры команды ps. Остальные параметры Вы можете узнать, просто набрав man ps.

Пример1:

[gserg@WEBMEDIA gserg]$ ps

PID TTY TIME CMD

3126 pts/2 00:00:00 bash

3158 pts/2 00:00:00 ps

Пример2:

[gserg@WEBMEDIA gserg]$ ps 3126

PID TTY STAT TIME COMMAND

3126 pts/2 S 0:00 /bin/bash

Пример3:

[gserg@WEBMEDIA gserg]$ ps -ef

UID PID PPID C STIME TTY TIME CMD

root 1 0 0 10:01 ? 00:00:03 init [5]

root 2 1 0 10:01 ? 00:00:00 [keventd]

root 3 1 0 10:01 ? 00:00:00 [kapmd]

root 4 1 0 10:01 ? 00:00:00 [ksoftirqd_CPU0]

root 5 1 0 10:01 ? 00:00:24 [kswapd]

root 6 1 0 10:01 ? 00:00:00 [bdflush]

gserg 3126 3124 0 17:56 pts/2 00:00:00 /bin/bash

gserg 3160 3126 0 17:59 pts/2 00:00:00 ps -ef

Пример4:

[gserg@WEBMEDIA gserg]$ ps -efw

UID PID PPID C STIME TTY TIME CMD

root 1 0 0 10:01 ? 00:00:03 init [5]

root 2 1 0 10:01 ? 00:00:00 [keventd]

root 3 1 0 10:01 ? 00:00:00 [kapmd]

root 4 1 0 10:01 ? 00:00:00 [ksoftirqd_CPU0]

root 5 1 0 10:01 ? 00:00:24 [kswapd]

root 1130 1 0 10:02 ? 00:00:00 /usr/sbin/apmd -p 10 -w 5 -W -P /etc/sysconfig/apm-scripts/apmd_proxy

gserg 3172 3126 0 18:01 pts/2 00:00:00 ps -efw

Читать еще:  Архитектура современного пк

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

На самом деле операционная система воспринимает работающего в ней пользователя как набор запущенных от его имени процессов. Ведь и сам сеанс пользователя открывается в командной оболочке (или оболочке Х) от имени пользователя. Поэтому когда мы говорим «права доступа пользователя к файлу» то подразумеваем «права доступа процессов, запущенных от имени пользователя к файлу».

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

Как правило, реальные и эффективные идентификаторы процессов одинаковые, но есть и исключения. Например, для работы утилиты passwd необходимо использовать идентификатор суперпользователя, так как только суперпользователь имеет права на запись в файлы паролей. В этом случае эффективные идентификаторы процесса будут отличаться от реальных. Возникает резонный вопрос — как это было реализовано?

У каждого файла есть набор специальных прав доступа — биты SUID и SGID. Эти биты позволяют при запуске программы присвоить ей эффективные идентификаторы владельца и группы-владельца соответственно и выполнять процесс с правами доступа другого пользователя. Так как файл passwd принадлежит пользователю root и у него установлен бит SUID, то при запуске процесс passwd будет обладать правами пользователя root.

Устанавливаются биты SGID и SUID командой chmod:

chmod u+s filename — установка бита SUID

chmod g+s filename — установка бита SGID

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

Родителем всех процессов в системе является процесс init. Его PID всегда 1, PPID — 0. Всю таблицу процессов можно представить себе в виде дерева, в котором корнем будет процесс init. Этот процесс хоть и не является частью ядра, но выполняет в системе очень важную роль — определяет текущий уровень инициализации системы и следит чтобы были запущены программы, позволяющие пользователю общаться с компьютером (mingetty, X или другие).

Процессы, имена которых заключены в квадратные скобки, например «[keventd]» — это процессы ядра. Эти процессы управляют работой системы, а точнее такими ее частями, как менеджер памяти, планировщик времени процессора, менеджеры внешних устройств и так далее.

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

Жизнь каждого процесса представлена следующими фазами:

Создание процесса — на этом этапе создается полная копия того процесса, который создает новый. Например, вы запустили из интерпретатора на выполнение команду ls. Командный интерпретатор создает свою полную копию.

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

Выполнение процесса

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

Умирание процесса — после всех завершающих стадий удаляется запись из таблицы процессов — процесс завершил свою работу.

Во время работы процесса, ядро контролирует его состояние, и в случае возникновения непредвиденной ситуации управляет процессом с помощью посылки ему сигнала. Сигнал — это простейший способ межпроцессорного (то есть между процессами) взаимодействия. Существует несколько типов сигналов. Для каждого из типов предусмотрено действие по умолчанию. Процесс может воспользоваться действием по умолчанию, или, если у него есть обработчик сигнала, то он может перехватить и обработать или игнорировать сигнал. Сигналы SIGKILL и SIGSTOP невозможно ни перехватить, ни игнорировать.

По умолчанию возможны несколько действий:

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

завершить — завершить работу процесса.

завершить + core — завершить работу процесса и создать файл в текущем каталоге с именем core, содержащий образ памяти процесса (код и данные).

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

Вот список всех сигналов, существующих в системе на сегодняшний день:

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

Материал этой статьи ни в коем случае не претендует на свою избыточность. Более подробно о процессах вы можете прочитать в книгах, посвященных программированию под UNIX.

Процессы. Системные вызовы fork() и exec(). Нити.

Процесс в Linux (как и в UNIX) — это программа, которая выполняется в отдельном виртуальном адресном пространстве. Когда пользователь регистрируется в системе, автоматически создается процесс, в котором выполняется оболочка (shell), например, /bin/bash.

В Linux поддерживается классическая схема мультипрограммирования. Linux поддерживает параллельное (или квазипараллельного при наличии только одного процессора) выполнение процессов пользователя. Каждый процесс выполняется в собственном виртуальном адресном пространстве, т.е. процессы защищены друг от друга и крах одного процесса никак не повлияет на другие выполняющиеся процессы и на всю систему в целом. Один процесс не может прочитать что-либо из памяти (или записать в нее) другого процесса без «разрешения» на то другого процесса. Санкционированные взаимодействия между процессами допускаются системой.

Ядро предоставляет системные вызовы для создания новых процессов и для управления порожденными процессами. Любая программа может начать выполняться только если другой процесс ее запустит или произойдет какое-то прерывание (например, прерывание внешнего устройства).

В связи с развитием SMP (Symmetric Multiprocessor Architectures) в ядро Linux был внедрен механизм нитей или потоков управления (threads). Нить — это процесс, который выполняется в виртуальной памяти, используемой вместе с другими нитями процесса, который обладает отдельной виртуальной памятью.

Если интерпретатору (shell) встречается команда, соответствующая выполняемому файлу, интерпретатор выполняет ее, начиная с точки входа (entry point). Для С-программ entry point — это функция main. Запущенная программа тоже может создать процесс, т.е. запустить какую-то программу и ее выполнение тоже начнется с функции main.

Для создания процессов используются два системных вызова: fork() и exec. fork() создает новое адресное пространство, которое полностью идентично адресному пространству основного процесса. После выполнения этого системного вызова мы получаем два абсолютно одинаковых процесса — основной и порожденный. Функция fork() возвращает 0 в порожденном процессе и PID (Process ID — идентификатор порожденного процесса) — в основном. PID — это целое число.
Теперь, когда мы уже создали процесс, мы можем запустить программу с помощью вызова exec. Параметрами функции exec является имя выполняемого файла и, если нужно, параметры, которые будут переданы этой программе. В адресное пространство порожденного с помощью fork() процесса будет загружена новая программа и ее выполнение начнется с точки входа (адрес функции main).

Читать еще:  Информация о процессе linux

В качестве примера рассмотрим этот фрагмент программы

if (fork()==0) wait(0);
else execl(«ls», «ls», 0); /* порожденный процесс */

Теперь рассмотрим более подробно, что же делается при выполнении вызова fork():

  1. Выделяется память для описателя нового процесса в таблице процессов
  2. Назначается идентификатор процесса PID
  3. Создается логическая копия процесса, который выполняет fork() — полное копирование содержимого виртуальной памяти родительского процесса, копирование составляющих ядерного статического и динамического контекстов процесса-предка
  4. Увеличиваются счетчики открытия файлов (порожденный процесс наследует все открытые файлы родительского процесса).
  5. Возвращается PID в точку возврата из системного вызова в родительском процессе и 0 — в процессе-потомке.

Общая схема управления процессами
Каждый процесс может порождать полностью идентичный процесс с помощью fork(). Родительский процесс может дожидаться окончания выполнения всех своих процессов-потомков с помощью системного вызова wait.
В любой момент времени процесс может изменить содержимое своего образа памяти, используя одну из разновидностей вызова exec. Каждый процесс реагирует на сигналы и, естественно, может установить собственную реакцию на сигналы, производимые операционной системой. Приоритет процесса может быть изменен с помощью системного вызова nice.

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

Примеры сигналов:

  1. окончание порожденного процесса (например, из-за системного вызова exit (см. ниже))
  2. возникновение исключительной ситуации
  3. сигналы, поступающие от пользователя при нажатии определенных клавиш.

Установить реакцию на поступление сигнала можно с помощью системного вызова signal
func = signal(snum, function);

snum — номер сигнала, а function — адрес функции, которая должна быть выполнена при поступлении указанного сигнала. Возвращаемое значение — адрес функции, которая будет реагировать на поступление сигнала. Вместо function можно указать ноль или единицу. Если был указан ноль, то при поступлении сигнала snum выполнение процесса будет прервано аналогично вызову exit. Если указать единицу, данный сигнал будет проигнорирован, но это возможно не для всех процессов.

С помощью системного вызова kill можно сгенерировать сигналы и передать их другим процессам.
kill(pid, snum);
где pid — идентификатор процесса, а snum — номер сигнала, который будет передан процессу. Обычно kill используется для того, чтобы принудительно завершить («убить») процесс.
Pid состоит из идентификатора группы процессов и идентификатора процесса в группе. Если вместо pid указать нуль, то сигнал snum будет направлен всем процессам, относящимся к данной группе (понятие группы процессов аналогично группе пользователей). В одну группу включаются процессы, имеющие общего предка, идентификатор группы процесса можно изменить с помощью системного вызова setpgrp. Если вместо pid указать -1, ядро передаст сигнал всем процессам, идентификатор пользователя которых равен идентификатору текущего выполнения процесса, который посылает сигнал.

Как посмотреть запущенные процессы в Linux

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

pstree

У утилиты pstree есть опции, вводить их нужно так:
pstree

Вот основные, часто используемые:
pstree -a показать без потоков
pstree -p показать id процесса (порядковый номер запущенной программы/процесса)
pstree -c отключить компактный показ и показать в развернутом виде компактном виде
pstree

процесс с таким pid и процессы/потоки, отходящие от него
pstree показать процессы указанного пользователя

ps -ax показать все запущенны процессы с: pid, из какого терминала запущен, команда с помощью которой запускался процесс и его файл
ps -aux показать все запущенные процессы, но с еще большим количеством информации (как ах + пользователь, время старта процесса, потребляемая память и затраты ЦП)
ps -ely покажет помимо pid еще и ppid (родительский процесс) — тот процесс, который запустил данных процесс (программа)

В случае где в столбце TTY (терминал) стоит ? значит, что скорее всего процесс был запущен либо на старте ОС, либо он откреплен от терминала (такие процессы называют демонами да, да 😀 )

(нужно ли об этом подробнее рассказать?)

У утилиты еще много различных опций, но ими я не пользовался

top и htop

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

top покажет список процессов запущенных в данные момент с информацией о PID, пользователе, приоритете, потребляемом количестве оперативной памяти и ресурса процессора, название само команды и др.
Вверху будет показана информация об общем количестве запущенных процессов, а также сколько из них находятся в различных состояниях (запущенные, спящие, остановленные, зомби). Также показывается общее, используемое, свободное и буферизованное/кешированное количество памяти.
Для выхода из утилиты нажмите q

htop показывает почти то же самое, но гораздо в более удобном формате, кроме того, можно легко отфильтровать по определенному свойству процессы (например, по возрастанию PID или по количеству используемой памяти или иное), некоторые колонки свойств можно убрать или наоборот добавить недостающие. А еще наглядно показываются потоки у процессов, если они есть. Вверху есть полосы, показывающие сколько использовано оперативной памяти и ресурсов процессора, в том числе для каждого ядра процессора. Самое приятное, что хоть это и консольная программа, но она цветная, поэтому можно быстро визуально найти нужную информацию.
Внизу показаны подсказки, на какую клавишу нажать, чтобы залезть в настройки.
переключение между режимом просмотра, режимом сортировки процессов по свойствам и режимом настройки утилиты происходит по нажатию (угловых скобок). А если часть названия процесса не умещается на экран, но понажимайте -> и

Как Узнать Список Процессов Linux с Помощью Командной Строки

Введение

Процесс — это системный термин, который используется для описания приложения или программы. К примеру, когда мы открываем веб-браузер Google Chrome, мы можем сказать, что это процесс ответственный за запуск/выполнение Chrome, который был запущен и выполняется до тех пор пока мы не закроем браузер. Даже когда мы выполняем любую bash команду, появляется новый процесс. Если мы откроем одно и тоже приложение дважды, появится два процесса. В этом руководстве вы узнаете, как узнать список процессов Linux с помощью командной строки. Это необходимо, если вы хотите узнать какие процессы запущены в данный момент, каким пользователем запущен процесс или просто узнать какой из процессов использует больше всего ресурсов сервера.

Читать еще:  Ошибка при синтаксическом анализе пакета android

Что вам понадобится

Перед тем, как вы начнете это руководство, вам понадобится следующее:

  • Доступ к командной строке

Шаг 1 — Просмотр списка процессов Linux

Список терминов которые вам необходимо знать перед прочтением руководства:

  1. PID — идентификатор процесса. Каждый процесс имеет свой 5 значный код. Эти числа могут закончиться и начать повторяться, но в любое другое время у каждого процесса свой уникальный PID.
  2. PPID — родительский идентификатор процесса. Идентификатор процесса который запустил этот конкретный процесс.

Две самые часто используемые команды для показа списка процессов Linux это top и ps. Разница между ними заключается в том, что top чаще используется в интерактивном режиме, а ps больше используется в скриптах, в сочетании с другими bash командами.

top — возможно одна из самых базовых и часто используемых команд для отображения процесса, который потребляет наибольшее количество ресурсов сервера. После выполнения данной команды, вы должны увидеть похожее окно:

top само по себе является приложением, после выполнения команды появится новая таблица с постоянно обновляющимся списком процессов Linux. С данной таблицей можно взаимодействовать посредством клавиатуры. Вот несколько примеров:

  • h или ? — отобразить окно помощи со всеми командами и другой полезной информацией.
  • space — нажатие пробела на вашей клавиатуре вручную обновит таблицу процессов.
  • f — добавить поле для отображения в новом окне или удалить определенные поля в таблице.
  • q — выйти из приложения или дополнительных окон принадлежащих к нему. К примеру, после использования функции f.
  • l — включить отображение информации о средней загрузке и времени работы.
  • m — включить отображение информации о памяти.
  • P (Shift + p) — отсортировать процессы по количеству используемой памяти.
  • s — изменить задержку между обновлениями списка (вам будет предложено ввести значение в секундах).

Вы также можете использовать определенные опции с командой top:

  • -d delay — укажите задержку между обновлениями вместо delay.
  • -n number — обновить страницу определенное число раз и выйти из приложения. Вместо number введите значение.
  • -p pid — отображать и контролировать процессы только с определенным (pid).
  • -q — обновлять без какой-либо задержки.

Для получения информации о других полезных командах для клавиатуры, посетите данный сайт.

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

Другие полезные применения команды top:

  • Для отображения процессов определенного пользователя, вы можете использовать это: top -u user
  • Для закрытия процесса, нажмите в окне приложения top клавишу k на клавиатуре. Далее, вам будет предложено вписать идентификатор процесса (pid), который вы хотите закрыть.
  • Вы можете сохранить текущие настройки команды top используя сочетание клавиш Shift + W. Эти настройки будут сохранены в директории /root/.toprc

ps — Еще одна полезная команда для отображения списка процессов Linux. Вот несколько опций часто используемых с этой командой:

  • -e — отображение всех процессов.
  • -f — полное форматирование списка.
  • -r — отображение запущенных процессов.
  • -u — опция для показа процессов определенного пользователя или пользователей.
  • —pid — опция для фильтрации процессов по PID.
  • —ppid — опция для фильтрации процессов по родительскому PID.
  • -C — фильтровать процессы по их имени или команде.
  • -o — отображение информации, связанной с пробелом или списком ключевых слов, разделенных запятыми.

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

  1. ps -ef — отобразит список процессов, которые запущены прямо сейчас (еще одна похожая команда ps aux)
  2. ps -f -u user1,user2 — отобразит все процессы основанные на предоставленном UID (ID пользователя или имени пользователя).
  3. ps -f —pid id — отобразит процессы основанные на pid. Введите идентификатор процесса вместо id. Может быть использована вместе с PPID.
  4. ps -C command/name — фильтрация процессов по их имени или команде.
  5. ps aux —sort=-pcpu,+pmem — отобразит процессы потребляющие большое количество ресурсов ЦПУ.
  6. ps -e -o pid,uname,pcpu,pmem,comm — используется для фильтрации определенных столбцов с последующим их отображением.
  7. ps -e -o pid,comm,etime — эта команда отобразит время прошедшее с запуска процесса.

Мы рекомендуем посетить эту страницу для получения более подробной информации об использовании команды ps.

Шаг 2 — Закрытие и расстановка приоритета процессов

В предыдущем шаге мы уже рассказывали о том, как можно закрыть процесс с помощью команды top. Этот же результат может быть достигнут при помощи команды kill. К примеру:

kill pid — впишите вместо PID идентификатор процесса, который вы хотите закрыть. Если процесс довольно упрямый и не хочет быть закрыт, вы можете использовать команду: kill -9 pid.

Еще одной командой для управления процессами является NICE. Обычно она используется для расстановки приоритетов для процессов, когда на вашей системе их запущено действительно много. В этом случае ваша система узнает какие из процессов являются важными и установит для них более высокий приоритет. Проще говоря, она помогает вам расставить приоритеты процессов от более важных к менее важным. Система будет запускать процесс, который имеет меньший приоритет только в том случае, если для этого имеется достаточно ресурсов ЦПУ. Этой команде можно задать значение от -20 до 19, чем меньше значение, тем выше приоритет процесса. Стандартный приоритет для всех приложений . Основным синтаксисом будет:

  • nice -n ‘значение’ process name — Пример: nice -n 10 name. Это начнет новый процесс с выбранным приоритетом (10).
  • Если вы хотите задать значение приоритета для уже запущенного приложения используйте: renice ‘значение’ -p ‘PID’ — Пример: renice ’10’ -p ‘54125’.

Заключение

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

Ссылка на основную публикацию
ВсеИнструменты 220 Вольт
Adblock
detector