Debian остановить процесс. Linux: как убить процесс с помощью терминальных команд. Использование команды ps

Задания и процессы

Всякая выполняющаяся в 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 . Восстановить прерванное задание никаким образом невозможно. Следует также знать, что некоторые программы перехватывают сигнал 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 & + 164 /home/larry#

Сообщение представляет собой номер задания (job number) для процесса yes. Командная оболочка присваивает номер задания каждому исполняемому заданию. Поскольку yes является единственным исполняемым заданием, ему присваивается номер 1. Число 164 является идентификационным номером, соответствующим данному процессу (PID ), и этот номер также дан процессу системой. Как мы увидим дальше, к процессу можно обращаться, указывая оба этих номера.

Итак, теперь у нас есть процесс команды yes, работающий в фоне, и непрерывно посылающий поток из букв y на устройство /dev/null . Для того, чтобы узнать статус этого процесса, нужно исполнить команду jobs , которая является внутренней командой оболочки.

/home/larry# jobs + Running yes >/dev/null & /home/larry#

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

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

Теперь введём команду jobs снова, чтобы проверить результат предыдущего действия:

/home/larry# jobs 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 + Stopped yes >/dev/null /home/larry#

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

Для возобновления выполнения задания на переднем плане можно использовать команду fg (от слова foreground - передний план).

/home/larry# fg yes >/dev/null

Командная оболочка ещё раз выведет на экран название команды, так что пользователь будет знать, какое именно задание он в данный момент запустил на переднем плане. Приостановим это задание ещё раз нажатием клавиш Ctrl -Z , но в этот раз запустим его в фоновый режим командой bg (от слова background - фон). Это приведёт к тому, что данный процесс будет работать так, как если бы при его запуске использовалась команда с символом & в конце (как это делалось в предыдущем разделе):

/home/larry# bg + 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 являются внутренними командами оболочки. Если, по некоторой причине, вы используете командную оболочку, которая не поддерживает функции управления заданиями, то вы в ней этих (и подобных) команд не отыщете.

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

Наиболее простой и универсальный способ убить процесс в Linux — это использование терминальных команд. Данный вариант будет работать на любом дистрибутиве Linux.

Процессы в Linux

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

Все процессы, работающие в Linux, имеют такие атрибуты:

1. PID — уникальный для каждого процесса идентификатор.
2. PPID — идентификатор родительского процесса.
3. Идентификатор пользователя, запустившего процесс.
4. Приоритет.
5. Состояние процесса.

Каждый запущенный процесс находится в одном из состояний:

• "Выполняется". Для обозначения этого состояния используется буква R.
• Процесс, который запустил системную операцию, например ввод или вывод данных, и ждет когда завершится ее выполнение, называется "Ожидание". Обозначается буквой S.
• Процесс, который остановлен пользователем или ОС Linux, находится в состоянии "Остановлен". Это состояние обозначается символом Т.
• "Зомби" - процессы, которые больше не выполняются, но потребляют ресурсы операционной системы. Обозначаются буквой Z.
• Непрерывный процесс нельзя завершить, пока не закончится операция прямого доступа в память. Обозначается процесс символом D.

Поиск процесса

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

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

• PID - уникальный номер процесса;
• USER - логин пользователя, который запустил данный процесс;
• PR - приоритет процесса в данный момент времени;
• NI - приоритет присвоенные процессу командой NICE;
• S- состояние данного процесса;
• %CPU- сколько процессорного времени занимает данный процесс (в процентах);
• %MEM- объем оперативной памяти, которую занимает данный процесс (в процентах);
• TIME+ - сколько времени прошло с момента запуска процесса;
• COMMAND - программа, которая запустила процесс.

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

• отсортировать процессы по объему занимаемой оперативной памяти (столбец %MEM) нужно нажать комбинацию клавиш Shift+M;
• отсортировать по номеру процесса (столбец PID) можно при помощи комбинации Shift+N;
• отсортировать по времени работы (столбец TIME+) - Shift+T.
• вернуться к исходной сортировке по уровню загрузки центрального процессора - нажать комбинацию Shift+P.

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

При помощи команды top можно получить множество необходимых сведений, однако это не самый удобный способ получения необходимой информации о нужном вам процессе. Чтобы не искать нужный процесс, можно воспользоваться командой ps и фильтровать список при помощи команды greep. Например, если нужно найти все процессы, связанные с запущенным браузером Opera, можно ввести команду ps axu | grep Mozilla.

Команда ps обладает следующими параметрами:

• a - показать процессы для всех пользователей;
• u - отобразить пользователя, который является владельцем процесса;
• x - показывают процессы, не привязанные к терминалу. Данная опция важна при поиске информации о графическом приложении.

При помощи связки команд ps и grep можно получить всю информацию, необходимую для уничтожения зависшего приложения.

Другие способы поиска процесса

Для того чтобы найти PID процесса по его имени, существует команда pidof. Формат ее использования следующий: pidof+имя программы. Например, чтобы найти все PID, относящиеся к программе Opera, нужно ввести: pidof Opera.

В некоторых случаях бывает так, что программа завершила свое выполнение, но не освободила сетевой порт. Чтобы получить сведения, в данном случае нужно ввести команду fuser: fuser -vn tcp 80. Где 80 - это номер зависшего порта. После этого можно убить процесс Linux по порту.

После того как вы узнали PID процесса и его имя, можно приступить к операции завершения ненужного приложения. Для этого используются две команды: kill - убить процесс по id в Linux и killall - завершить выполнение программы по имени.

Структура команды kill: kill SIGNAL PID. Где SIGNAL - это сигнал, который должен быть отправлен, а PID - это идентификатор процесса.

Параметр SIGNAL завершения процесса равен 9 (SIGKILL). Таким образом, чтобы в Linux убить процесс по pid нужно ввести в консоли команду: kill -9 9578. Где 9578 уникальный номер процесса.

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

Полезно также знать другие значения, которые может принимать параметр SIGNAL. Например, для перезагрузки зависшей программы можно использовать параметр HUP. Сигнал SIGTERM не прерывает работу программы мгновенно, а дает время для корректного завершения работы, то есть приложение сохраняет данные, завершает свое выполнение, и освобождает все занятые ресурсы.

Как в Linux убить процесс по имени

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

Правда, данная команда не всегда завершает процессы, относящиеся к уничтожаемой программе. Если после выполнения вышеуказанной команды вы введете комбинацию ps aux | grep Opera и увидите, что некоторые процессы еще выполняются, лучше всего завершить их при помощи системного приложения kill.

В некоторых случаях, чтобы в Linux убить процесс, запущенный другим пользователем, могут потребоваться права root. Тогда перед командой завершения процесса нужно ввести команду sudo.

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

Автор: Damien
Дата публикации: 8 октября 2013 года
Перевод: А. Кривошей
Дата перевода: апрель 2014 г.

Независимо от того, какую операционную систему вы используете, каждый из нас сталкивался с ситуацией, когда необходимо закрыть зависшую программу. В Linux (и в Mac) есть команда "kill", которую можно использовать для принудительного завершения работы приложений. В этом руководстве я покажу вам несколько различных способов ее использования.

Команды и сигналы Kill

Когда вы выполняете команду "kill", то фактически вы посылаете системе сигнал, чтобы заставить ее завершить некорректно ведущее себя приложение. Всего вы можете использовать до 60 сигналов, но все, что нужно знать, это SIGTERM (15) и SIGKILL (9).

Вы можете просмотреть все сигналы с помощью команды:

SIGTERM - этот сигнал запрашивает остановку работы процесса. Он может быть проигнорирован. Процессу дается время на корректное завершение. Если программа завершается корректно, значит она использовала данное время на то, чтобы сохранить свое состояние или результаты работы и освободить ресурсы. Другими словами, ее не заставляли остановиться.
SIGKILL - этот сигнал заставляет процесс прекратить работу немедленно. Программа не может проигнорировать этот сигнал. Несохраненные результаты будут потеряны.

Синтаксис использования "kill":

$ kill [сигнал или опция] PID

Сигнал по умолчанию (если он не задан) - SIGTERM. Если он не помогает, для принудительного завершения процесса можно использовать следующие варианты:

$ kill SIGKILL PID $ kill -9 PID

где флаг "-9" ссылается на сигнал SIGKILL.

Если вы не знаете точно PID приложения, просто запустите команду:

Она выведет информацию по всем запущенным программам.

Например, чтобы завершить Chrome, я введу команду:

Также обратите внимание, что можно завершать несколько процессов одной командой.

$ kill -9 PID1 PID2 PID 3

PKill

Команда "pkill" позволяет использовать расширенные шаблоны регулярных выражений и другие критерии соответствия. Вместо использования PID вы теперь можете завершить приложение, введя имя его процесса. Например, для завершения работы Firefox просто введите команду:

$ pkill firefox

Так как оно соответствует шаблону регулярного выражения, вы можете также ввести имя только частично, например:

Чтобы предотвратить завершение не тех приложений, которые требовалось, можно использовать команду "pgrep -l " для вывода списка всех подходящих процессов.

Killall

Killall также использует имя процесса вместо PID и завершает все экземпляры процесса с этим именем. Например, если вы запустили несколько экземпляров Firefox, вы можете завершить их все с помощью команды:

$ killall firefox

В Gnome вы можете перезапустить Nautilus с помощью команды:

$ killall nautilus

xkill

Xkill - это графический способ завершения приложений. Когда вы введете "xkill" в терминале, курсор примет вид крестика. Все, что вам требуется, кликнуть этим крестиком в окне нужного приложения и оно немедленно завершится. Если вам понравится такой способ, можно настроить для активации xkill горячие клавиши.

Заключение

Если приложение ведет себя неправильно и вызывает зависание системы, очень заманчиво перезагрузить компьютер и начать сеанс заново. С помощью этих команд "kill" вы можете завершить зависшее приложение без опасности для работы системы. Это особенно полезно для серверов, когда вы не хотите, чтобы зависшая программа привела к выключению всего сервера.

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

В этой статье мы рассмотрим несколько самых распространенных способов завершить процесс Linux. Опишем подробно как происходит остановка процесса и как все сделать правильно.

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

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

• SIGINT - самый безобидный сигнал завершения, означает Interrupt. Он отправляется процессу, запущенному из терминала с помощью сочетания клавиш Ctrl+C. Процесс правильно завершает все свои действия и возвращает управление;
• SIGQUIT - это еще один сигнал, который отправляется с помощью сочетания клавиш, программе, запущенной в терминале. Он сообщает ей что нужно завершиться и программа может выполнить корректное завершение или проигнорировать сигнал. В отличие от предыдущего, она генерирует дамп памяти. Сочетание клавиш Ctrl+/;
• SIGHUP - сообщает процессу, что соединение с управляющим терминалом разорвано, отправляется, в основном, системой при разрыве соединения с интернетом;
• SIGTERM - немедленно завершает процесс, но обрабатывается программой, поэтому позволяет ей завершить дочерние процессы и освободить все ресурсы;
• SIGKILL - тоже немедленно завершает процесс, но, в отличие от предыдущего варианта, он не передается самому процессу, а обрабатывается ядром. Поэтому ресурсы и дочерние процессы остаются запущенными.

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

Сначала Ctrl+C , если это возможно, затем SIGTERM - он хоть и завершает процесс, но делает эту культурно, и только в крайнем случае SIGKILL. А теперь рассмотрим как убить процесс по pid Linux на практике. Если вы всегда используете SIGKILL, тогда на ум приходит такая картинка:

Как убить процесс Linux?

Для передачи сигналов процессам в Linux используется утилита kill. Ее синтаксис очень прост:

$ kill -сигнал pid_процесса

Сигнал представляет собой один из выше перечисленных сигналов для завершения процесса. По умолчанию, если этот параметр не указан, используется сигнал SIGTERM, что является очень правильно. Также нам нужно указать какой процесс нужно завершить. Для этого используется уникальный идентификатор процесса - PID.

Допустим, у нас выполняется утилита ping. Мы хотим ее завершить с помощью kill. Тогда, сначала мы узнаем ее идентификатор с помощью команды ps:

ps aux | grep ping

В первой строчке отобразится сама утилита ping, а во второй сама программа ps. Берем нужный PID и завершаем процесс с помощью SIGTERM:

kill -TERM 20446

И только если после этой команды процесс продолжил висеть, а это вы можете проверить, выполнив ps. Только теперь можно выполнить SIGKILL:

kill -KILL 20446

Теперь снова проверяем:

Если процесс запущен от суперпользователя, то, естественно, вам нужно использовать sudo. Не всегда удобно уничтожать процесс по его PID, как минимум, потому, что вам этот PID нужно еще узнать. Мы могли бы нагородить сложных конструкций с использованием xargs, чтобы вычислять автоматически pid по имени процесса и сразу же его завершать, но в этом нет необходимости. Уже существуют специальные утилиты.

Как завершить процесс с помощью pkill

Утилита pkill - это оболочка для kill, она ведет себя точно так же, и имеет тот же синтаксис, только в качестве идентификатора процесса ей нужно передать его имя. Утилита сканирует директорию proc и находит PID первого процесса с таким именем, затем отправляет ему SIGTERM. Таким образом, вы можете убить процесс по имени Linux. Например, если мы хотим завершить тот же ping:

Также можно вручную задать тип сигнала:

pkill -TERM ping

Вместо ps, вы можете использовать утилиту pgrep для поиска pid процесса, убедимся что наша программа завершена:

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

Как остановить процесс с помощью killall

killall работает аналогично двум предыдущим утилитам. Она тоже приминает имя процесса в качестве параметра и ищет его PID в директории /proc. Но эта утилита обнаружит все процессы, с таким именем и завершит их. Например:

Как видите, запущено несколько процессов, осталось остановить процесс Linux с помощью killall:

Команда завершит все запущенные утилиты ping, вы можете убедиться в этом еще раз выполнив pgrep:

Выводы

В этой статье мы рассмотрели как убить процесс Linux. Иногда эта задача может быть очень полезной, но важно понимать, что ее нужно выполнять правильно. Нельзя сказать, что передача SIGKILL вместо SIGTERM очень опасна, но так делать не стоит. Надеюсь, эта информация была полезна для вас.

Как бы там ни было, рано или поздно мы сталкиваемся с необходимостью убить подглючивший или повисший процесс в Linux . Да-да, некоторые приложения в Linux иногда виснут, несмотря на стабильность свою стабильность. Именно в этих случаях вам пригодится замечательная утилита Kill . Давайте разберемся как пользоваться этой утилитой.

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

Идентификатор зависшего процесса

Для поиска нам понадобятся команды ps и grep . Команда ps — выведет для нас список активных процессов в системе и информации о них, а команда grep — будет выполнять поиск по результатам команды ps . Итак откроем терминал (ctrl+alt+t ) и посмотрим на активные процессы

ps axu

Как вы уже успели заметить список очень большой и листать его для поиска нужного нам процесса — лишняя трата времени, для этого мы и воспользуемся замечательной программой grep . Чтоб найти нужный нам процесс необходимо после ввода grep указать искомое нами приложение. На примере Viber, это выглядит так:

ps axu | grep viber pol 22685 0.0 1.9 647748 76620 ? Sl 13:01 0:04 /usr/bin/python /usr/bin/viberwrapper-indicator pol 22697 3.0 5.4 5402084 216120 ? Sl 13:01 4:52 /opt/viber/Viber pol 24068 0.0 0.0 17192 2216 pts/0 S+ 15:41 0:00 grep --color=auto viber

В первой строке запущенное приложение viberwrapper-indicator, об этом приложении можно почитать . Вторя строка непосредственно сам Viber который мы и будем сегодня «тушить», но что же за третья строка? Третий процесс это сам процесс grep , так как в качестве параметра поиска мы указали слово viber, и grep нашел сам себя в выводе команды ps .

Есть еще один более простой способ узнать PID процесса - это команда pidof , которая принимает в качестве параметра название процесса и выводит его PID. Будьте внимательны к регистру, если название процесса начинается с заглавной буквы, а вы напишете его с маленькой(или наоборот), то pidof его не нейдет

pidof Viber

Как вы уже успели заметить мне выдало 3 строки с активным приложением Viber

Завершение процесса или проще говоря «Убийство»

Теперь нам стал известен идентификатор процесса Viber и мы имеем возможность его «Убить»:

kill 22697

Вообще команда kill предназначена для посылки сигнала процессу. По умолчанию, если мы не указываем никакие атрибуты, посылается сигнал SIGTERM (от слова termination - завершение). SIGTERM указывает процессу на то, что необходимо завершиться. Каждый сигнал имеет свой номер. SIGTERM имеет номер 15. Список всех сигналов (и их номеров), которые может послать команда kill , можно вывести, выполнив kill -l . Чтобы послать сигнал SIGKILL (он имеет номер 9) процессу 22697, выполните в командой строке:

kill -9 22697

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

kill -l