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

Убиваем процессы в Linux — команды ps, kill и killall

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

Один из способов «убить», запущенное приложение в Linux, это использование таких команд, как kill или killall.

Рассмотрим, как использовать эти команды, находить PID процесса и посылать сигнал SIGKILL.

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

Находим PID зависшего процесса

Каждый процесс в Linux имеет свой идентификатор, называемый PID. Перед тем, как выполнить остановку процесса, нужно определить его PID. Для этого воспользуемся командами ps и grep.

Команда ps предназначена для вывода списка активных процессов в системе и информации о них. Команда grep запускается одновременно с ps (в канале) и будет выполнять поиск по результатам команды ps.

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

ps axu

Но, как правило, список очень большой и найти процесс, который мы хотим «убить», бывает не так просто. Здесь на помощь приходит команда grep. Например, чтобы найти информацию о процессе с именем gcalctool выполните команду:

ps axu | grep gcalctool

Команда grep выполнит поиск по результатам команды ps и на экран будут выведены только те строки, которые содержат строку (слово) gcalctool. Здесь есть одна интересная деталь, например, если у вас не запущено приложение gcalctool, то после выполнения ps axu | grep gcalctool вы получите:

$ ps axu | grep gcalctool
yuriy 25587 0.0 0.0 10636 884 pts/2 S+ 10:20 0:00 grep —color=auto gcalctool

То есть мы получили сам процесс grep, так как в качестве параметра команде мы указали слово gcalctool, и grep нашел сам себя в выводе команды ps.

Если процесс gcalctool запущен, то мы получим:

yuriy@yuriy-NIX:~$ ps axu | grep gcalctool
yuriy 25609 7.6 0.4 500840 17964 ? Sl 10:20 0:00 gcalctool
yuriy 25624 0.0 0.0 10640 884 pts/2 S+ 10:21 0:00 grep —color=auto gcalctool

Здесь нас интересует строка: «yuriy 25609 7.6 0.4 500840 17964 ? Sl 10:20 0:00 gcalctool». Число 25609 и есть идентификатор (PID) процесса gcalctool.

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

$ pidof gcalctool
25609

«Убиваем» процесс командой kill

Когда известен PID процесса, мы можем убить его командой kill. Команда kill принимает в качестве параметра PID процесса. Например, убьем процесс с номером 25609:

kill 25609

Вообще команда kill предназначена для посылки сигнала процессу. По умолчанию, если мы не указываем какой сигнал посылать, посылается сигнал SIGTERM (от слова termination — завершение). SIGTERM указывает процессу на то, что необходимо завершиться.

Каждый сигнал имеет свой номер. SIGTERM имеет номер 15. Список всех сигналов (и их номеров), которые может послать команда kill, можно вывести, выполнив kill -l.

Чтобы послать сигнал SIGKILL (он имеет номер 9) процессу 25609, выполните в командой строке:

kill -9 25609

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

Убиваем процессы командой killall

Команда killall в Linux предназначена для «убийства» всех процессов, имеющих одно и то же имя. Это удобно, так как нам не нужно знать PID процесса. Например, мы хотим закрыть все процессы с именем gcalctool. Выполните в терминале:

killall gcalctool

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

killall -s 9 gcalctool

Заключение

Некоторые процессы не удается остановить под обычным пользователем. Например, если процесс был запущен от имени пользователя root или от имени другого пользователя системы, то команды kill и killall нужно выполнять от имени суперпользователя, добавляя sudo (в Ubuntu):

sudo kill 123

Бывают ситуации, когда вы работаете в графическом интерфейсе (например, GNOME) и вам не удается открыть эмулятор терминала, чтобы остановить зависший процесс. Тогда можно переключиться на виртуальную консоль клавишами Ctrl+Alt+F1, залогиниться в ней и выполнять команды уже из нее. А потом перейти обратно, нажав Ctrl+Alt+F7.

Справку по использованию любой команды можно получить командой man:

man ps
man grep
man pidof
man kill
man killall

Источник: https://pingvinus.ru/note/ps-kill-killall

linux — Как я могу убить процесс по имени вместо PID? — Qaru

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

jeremy@jeremy-desktop:~$ ps aux | grep firefox
jeremy 7451 25.0 27.4 170536 65680 ? Sl 22:39 1:18 /usr/lib/firefox-3.0.1/firefox
jeremy 7578 0.0 0.3 3004 768 pts/0 S+ 22:44 0:00 grep firefox
jeremy@jeremy-desktop:~$ kill 7451

То, что я хочу, — это команда, которая сделает все это для меня. Для него потребуется строка ввода и grep (или что-то еще) в списке процессов и убьют все процессы на выходе:

jeremy@jeremy-desktop:~$ killbyname firefox

Я попытался сделать это на PHP, но exec ('ps aux'), похоже, показывает только процессы, которые были выполнены с exec() в самом PHP script (так что единственный процесс, который он показывает, сам).

задан Jeremy Ruten 02 окт. '08 в 7:57источник поделиться

Вы можете убивать процессы по имени killall<\p>

Но если вы не видите процесс с ps aux, вы, вероятно, не будете иметь право его убить…

ответ дан Andre Bossard 02 окт. '08 в 8:05источник поделиться

Также можно использовать:

pkill -f «Process name».

Для меня это работает отлично, это то, что я искал. В моем случае без флага pkill не работал с именем.

Когда -f установлен, для сопоставления шаблонов используется полная командная строка.

ответ дан Victor 07 янв. '15 в 16:49источник поделиться

На Mac я не мог найти pgrep и pkill, ни один из них не работал, поэтому написал простой один лайнер script: —

export pid=`ps | grep process_name | awk 'NR==1{print $1}' | cut -d' ' -f1`;kill $pid

Если есть более простой способ сделать это, разделите.

ответ дан Dhiraj 22 февр. '13 в 2:32источник поделиться

Самый простой способ — сначала проверить, что вы получаете правильные идентификаторы процессов:

pgrep -f [part_of_a_command]

Если результат будет таким, как ожидалось. Пойдите с:

pkill -f [part_of_a_command]
ответ дан Tahsin Turkoz 12 июля '16 в 22:53источник поделиться

Странно, но я не видел решения вроде этого:

kill -9 `pidof firefox`

он может также убить несколько процессов (несколько pids), например:

kill -9 `pgrep firefox`

Я предпочитаю pidof, поскольку он имеет один вывод строки:

> pgrep firefox
6316
6565
> pidof firefox
6565 6316
ответ дан prosti 02 окт. '16 в 23:17источник поделиться

более правильным будет:

export pid=`ps aux | grep process_name | awk 'NR==1{print $2}' | cut -d' ' -f1`;kill -9 $pid
ответ дан Chadiso 23 мая '14 в 10:47источник поделиться

Чтобы убить с помощью grep:

kill -9 `pgrep myprocess`
ответ дан edW 14 нояб. '14 в 23:14источник поделиться

Команда kill по умолчанию принимает имена команд в качестве альтернативы PID. См. kill (1).

Часто возникающая проблема заключается в том, что bash предоставляет свой собственный kill, который принимает номера заданий, такие как kill %1, но не имена команд. Это препятствует команде по умолчанию.

Если прежняя функциональность более полезна для вас, чем последняя, ​​вы можете отключить версию bash, вызвав

enable -n kill

Для получения дополнительной информации см. записи kill и enable в bash (1).

ответ дан The Vee 15 дек. '15 в 16:29источник поделиться

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

Как отказ от ответственности, я не профессионал, и, безусловно, есть возможности для улучшения.

Итак, я написал немного sh script:

#!/bin/sh killables=$(ps aux | grep $1 | grep -v mykill | grep -v grep)
if [ ! «${killables}» = «» ]
then echo «You are going to kill some process:» echo «${killables}»
else echo «No process with the pattern $1 found.» return
fi
echo -n «Is it ok?(Y/N)»
read input
if [ «$input» = «Y» ]
then for pid in $(echo «${killables}» | awk '{print $2}') do echo killing $pid «…» kill $pid echo $pid killed done
fi
ответ дан Fab 22 февр. '16 в 16:38источник поделиться

Убить все процессы, имеющие snippet в пути к запуску. Вы можете убить все приложения, запущенные из какого-либо каталога, для размещения/directory/в качестве фрагмента. Это очень полезно, если вы запускаете несколько компонентов для одного и того же приложения из одного и того же каталога приложений.

ps ax | grep | grep -v grep | awk '{print $1}' | xargs kill
ответ дан Mykhaylo Adamovych 05 апр. '17 в 16:03источник поделиться

Если вы запустите GNOME, вы можете использовать системный монитор (System- > Administration- > System Monitor) для уничтожения процессов, как в Windows. KDE будет иметь что-то подобное.

ответ дан Bernard 02 окт. '08 в 8:42источник поделиться

report this ad<\p>

Источник: http://qaru.site/questions/29428/how-can-i-kill-a-process-by-name-instead-of-pid

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

Мы покажем вам, как убить процесс в Linux. Одним из главных преимуществ Linux, является возможность завершить процесс без необходимости перезагрузки сервера. В этой статье мы покажем вам, как убить процесс в Linux с помощью команды kill, pkill и killall.

1. Что такое PID

Прежде чем мы начнем, мы должны знать, что такое ID процесса (PID).

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

В самом деле, например, первый процесс, который начинается в системе на базе Linux, это процесс, и его PID устанавливается в 1. Этот процесс является родителем всех остальных процессов.

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

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

ps -A

Это дает нам список всех запущенных процессов и их соответствующие PIDы.

Если мы хотим найти PID определенного процесса, мы можем использовать команду pidof  с последующим именем процесса. Например, чтобы узнать PID нашего процесса MySQL, можно выполнить следующую команду:

pidof mysql

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

ps aux | grep mysql

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

2. Убить процесс с помощью команды kill в Linux

Есть несколько важных правил, которые мы должны знать, прежде чем начать использовать команду kill.

  • Вы можете убить только собственные процессы, которые принадлежат вашему идентификатору пользователя
  • Вы не можете убивать процессы других пользователей
  • Вы не можете убить системные процессы (если вы не суперпользователь)
  • Пользователь root может убить процесс любого другого пользователя и любой системный процесс

Когда мы убиваем процесс с командой kill, мы на самом деле отправляем конкретный сигнал PID-регулятор, который мы хотим убить. Следующие сигналы используются командой kill:

1 = Hung up
9 = Kill 15 = Terminate

Сигнал hung up используется редко. Чаще всего мы используем сигнал kill, и если он не работает, то мы можем использовать сигнал Terminate.

Поэтому, как только мы находим PID процесса, который мы хотим убить, используйте один из методов, описанных нами ранее, мы можем использовать команду kill -9 PID, чтобы убить процесс с этого конкретного PID.

Например, если PID равный 6738, то мы можем использовать следующую команду:

kill -9 6738

3. Убить процесс с помощью команды pkill в Linux

Если вы хотите использовать имя процесса вместо его PID, чтобы убить его, то вы можете использовать команду pkill. Например, если процесс, который мы хотим убить называется MySQL, то мы можем использовать следующую команду, чтобы убить его:

Читайте также:  Обновление intel graphics update tool 2.0.3 для ubuntu 16.10

pkill mysql

4. Убить процесс с помощью команды killall в Linux

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

killall mysql

В этом примере мы убьем процесс MySQL и все его дочерние процессы.

Они являются наиболее распространенными примерами убийства процесса в Linux.

Источник: https://andreyex.ru/operacionnaya-sistema-linux/kak-ubit-process-v-linux/

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

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

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

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

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

ps axu

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

ps axu | grep viberpol 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

Comments

comments

Источник: http://linux-in.com/kill-in-linux/

Завершение процесса в Linux. Что понимается под «убийством» программы?

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

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

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

Для завершения работы процесса в Linux используется несколько специальных команд, но принцип их работы один и тот же. С помощью них вы посылаете операционной системе специальный сигнал и идентификационный номер процесса. Сигнал говорит о специфике остановки программы. Чаще всего используются SIGTERM (англ. Termination — завершение) и SIGKILL (англ. Kill — убийство).

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

SIGKILL также останавливает выполнение программы, но более грубым способом. Это безусловный сигнал завершения. Он не дает шанса на корректную остановку.

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

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

kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP

Завершение процесса по его PID

Если известен уникальный идентификационный номер процесса — PID, вы можете завершить его выполнение или убить с помощью команды kill. PID указывается в качестве первого параметра. При запуске команды kill без дополнительных опций, Linux посылает процессу сигнал SIGTERM. Для отправки другого сигнала его код нужно передать в опции.

#запустим текстовый редактор в фоновом режиме
gedit &
[1] 15892 #завершение работы с указанием кода сигнала и без
kill 15892
kill -9 15892

Заметка
Команда kill может завершить работу процесса, принадлежащего только текущему пользователю. Если вам нужно осуществить эту операцию над чужими процессами, необходимо войти в систему под администратором.

Завершение программы по её имени

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

#обычная остановка работы процесса
killall gedit #убийство процесса с указанием сигнала
killall -s 9 gedit

Дополнительные инструменты

Существует ещё несколько способов убийства процессов в Linux. Один из них связан с горячими клавишами. Если вы запустили программу в терминале и хотите завершить её не дожидаясь конца выполнения, нажмите сочетание клавиш Ctrl + C.

Также команда top, рассмотренная в прошлом уроке, имеет встроенный механизм завершения процессов. Для его использования необходимо нажать клавишу «k», ввести PID процесса и нажать Enter.

Источник: https://coder-booster.ru/learning/linux-beginners/ways-to-end-the-process

9 самых простых способов узнать идентификатор процесса (PID) в Linux

В основном, мы смотрим PID, чтобы убить невосприимчивую программу, и она похожа на диспетчер задач Windows.

Linux GUI также предлагает ту же функцию, но CLI — эффективный способ выполнения операции kill.

Что такое идентификатор процесса PID?

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

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

Процесс — это исполняемый экземпляр программы.

Каждый раз, идентификатор процесса будет получать изменения ко всем процессам, кроме init, поскольку init всегда является первым процессом в системе и является предком всех других процессов. Это PID — 1.Максимальное значение PID по умолчанию — 32 768.

Это было проверено, выполнив следующую команду в системе # cat/proc/sys/kernel/pid_maxВ 32-битных системах 32768 является максимальным значением, но мы можем установить любое значение до 2 ^ 22 (приблизительно 4 миллиона) в 64-битных системах.

Вы можете спросить, почему нам нужно такое количество PID? потому что мы не можем повторно использовать PID сразу. Также во избежание возможных ошибок.

PID для запущенных процессов в системе можно найти с помощью следующих девяти методов, таких как команда pidof, команда pgrep, команда ps, команда pstree, команда ss, команда netstat, команда lsof, команда fuser и команда systemctl.

  • pidof: pidof — найти идентификатор процесса запущенной программы.
  • pgrep: pgre — поиск или обработка сигналов на основе имени и других атрибутов.
  • ps: ps — сообщает моментальный снимок текущих процессов.
  • pstree: pstree — отображает дерево процессов.
  • ss: ss используется для вывода статистики сокетов.
  • netstat: netstat отображает список открытых сокетов.
  • lsof: lsof — список открытых файлов.
  • fuser: идентификаторы процессов в списке терминов всех процессов, которые открывают один или несколько файлов
  • systemctl: systemctl — Управление системой systemd и менеджером сервисов

В этом уроке мы рассмотрим идентификатор процесса Apache для проверки.

Метод-1: Использование команды pidof

pidof используется для поиска идентификатора процесса запущенной программы.

Он выводит эти идентификаторы на стандартный вывод.

Чтобы продемонстрировать это, мы узнаем идентификатор процесса Apache2 из системы Debian 9.

# pidof apache2 3754 2594 2365 2364 2363 2362 2361

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

Следовательно, нам нужно выяснить родительский PID (PPID), который мы ищем.

Это может быть первый номер. В моем случае это 3754, и он показан в порядке убывания.

Способ-2: Использование команды pgrep

pgrep просматривает текущие процессы и перечисляет идентификаторы процессов, которые соответствуют критериям выбора для stdout.

# pgrep apache2 2361 2362 2363 2364 2365 2594 3754

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

В моем случае это 3754.

Метод-3: Использование команды pstree

pstree показывает запущенные процессы как дерево.

Дерево коренится либо в pid, либо в init, если pid опущен.

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

pstree визуально объединяет идентичные ветви, помещая их в квадратные скобки и префикс  с количеством повторений.

# pstree -p | grep «apache2» |-apache2(3754)-+-apache2(2361) | |-apache2(2362) | |-apache2(2363) | |-apache2(2364) | |-apache2(2365) | `-apache2(2594)

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

# pstree -p | grep «apache2» | head -1 |-apache2(3754)-+-apache2(2361)

Команда pstree очень простая, потому что она отдельно разделяет родительский и дочерний процессы

Метод-4: Использование команды ps

ps отображает информацию о выборе активных процессов.

Он отображает идентификатор процесса (pid = PID), терминал, связанный с процессом (tname = TTY), кумулятивное время процессора в формате [DD-] hh: mm: ss (time = TIME) и исполняемое имя (ucmd = ЦМД).

По умолчанию выходной файл не сортируется.

# ps aux | grep «apache2» www-data 2361 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2362 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2363 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2364 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2365 0.0 0.4 302652 8400 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2594 0.0 0.4 302652 8400 ? S 06:55 0:00 /usr/sbin/apache2 -k start root 3754 0.0 1.4 302580 29324 ? Ss Dec11 0:23 /usr/sbin/apache2 -k start root 5648 0.0 0.0 12784 940 pts/0 S+ 21:32 0:00 grep apache2

Читайте также:  Релиз focuswriter 1.6.6 - полноэкранного текстового редактора

Из вышеприведенного вывода мы можем легко идентифицировать идентификатор родительского процесса (PPID) на основе даты начала процесса.

В моем случае процесс apache2 был запущен @ Dec11, который является родителем, а другие — дочерними. PID apache2 равен 3754.

Метод-5: Использование команды ss

ss используется для вывода статистики сокетов.

Он позволяет отображать информацию, аналогичную netstat.

Он может отображать больше информации о TCP и состоянии, нежели другие инструменты.

Он может отображать статистику для всех типов сокетов, таких как PACKET, TCP, UDP, DCCP, RAW, домен Unix и т. д.

# ss -tnlp | grep apache2 LISTEN 0 128 :::80 :::* users:((«apache2»,pid=3319,fd=4),(«apache2»,pid=3318,fd=4),(«apache2»,pid=3317,fd=4))

Метод-6: Использование команды netstat

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

По умолчанию netstat отображает список открытых сокетов.

Если вы не укажете каких-либо семейств адресов, будут выведены активные сокеты всех сконфигурированных семейств адресов.

Эта программа устарела. Замена для netstat — ss.

# netstat -tnlp | grep apache2 tcp6 0 0 :::80 :::* LISTEN 3317/apache2

Метод-7: использование команды lsof

lsof — список открытых файлов.

Команда lsof Linux выводит информацию о файлах, открытых для процессов, запущенных в системе.

# lsof -i -P | grep apache2 apache2 3317 root 4u IPv6 40518 0t0 TCP *:80 (LISTEN) apache2 3318 www-data 4u IPv6 40518 0t0 TCP *:80 (LISTEN) apache2 3319 www-data 4u IPv6 40518 0t0 TCP *:80 (LISTEN)

Метод-8: Использование команды fuser

Утилита fuser должна записывать на стандартный вывод идентификаторы процессов процессов, запущенных в локальной системе, которые открывают один или несколько именованных файлов.

# fuser -v 80/tcp USER PID ACCESS COMMAND 80/tcp: root 3317 F…. apache2 www-data 3318 F…. apache2 www-data 3319 F…. apache2

Метод-9: Использование команды systemctl

systemctl — Управление системой systemd и менеджером сервисов.

Это замена старого системного управления SysV и большинство современных операционных систем Linux были адаптированы systemd.

# systemctl status apache2 ● apache2.service — The Apache HTTP Server Loaded: loaded (/lib/systemd/system/apache2.service; disabled; vendor preset: enabled) Drop-In: /lib/systemd/system/apache2.service.d └─apache2-systemd.conf Active: active (running) since Tue 2018-09-25 10:03:28 IST; 3s ago Process: 3294 ExecStart=/usr/sbin/apachectl start (code=exited, status=0/SUCCESS) Main PID: 3317 (apache2)

Источник: http://itisgood.ru/2018/09/25/9-samyh-prostyh-sposobov-uznat-identifikator-processa-pid-v-linux/

Поиск процесса по имени в Linux

Что делать если вы новый пользователь Linux, как вы можете найти компьютерную программу/процесс по имени в Linux? Возможно ли найти процесс по имени вместо PID в Linux?

Запуск любой программа Linux создает процессы. Дочерний процесс в Linux — это процесс, созданный другим процессом.

Родительский процесс — это процесс, который создал один или несколько дочерних процессов в операционной системе.

Идентификатор процесса (ID или PID) — это номер, используемый ядрами операционной системы Linux или Unix. Он используется для уникальной идентификации активного процесса.

Процедура поиска процесса по имени в Linux

  1. Откройте терминал.

  2. Введите команду pidof следующим образом, чтобы найти PID для процесса firefox:pidof firefox
  3. Можно использовать команду ps вместе с командой grep следующим образом:ps aux | grep -i firefox
  4. Для поиска или обработки сигналов, основанных на использовании имени:pgrep firefox

Поиск процесса Linux по имени с помощью команды pgrep

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

$ pgrep -u root sshd

Просмотрите pid для процесса firefox:

$ pgrep firefox

Как использовать ‘ps aux | grep command’

Команда ps показывает информацию о выборе активных процессов:

$ ps aux $ ps aux | grep -i 'search-term' $ ps aux | grep 'firefox' $ ps aux | grep 'sshd'

Можно использовать следующий синтаксис вместо команды egrep:

$ ps -fC firefox $ ps -fC chrome

Опция -C запрашивает команду ps для выбора PID по имени команды.

Использование команды pidof для захвата PID любой программы в Linux

Команда pidof находит идентификаторы процесса (pids) названных программ, такие как sshd, firefox и т.д. Например:

$ pidof sshd $ pidof firefox

Пример вывода:

Заметка о команде top/htop

Для отображения процессов Linux используется команда top или htop:

$ top

ИЛИ

$ htop

Спасибо за уделенное время на прочтение статьи!

Если возникли вопросы, задавайте их в комментариях.

Источник: http://blog.sedicomm.com/2018/01/22/poisk-protsessa-po-imeni-v-linux/

Kill: Завершение неконтролируемых процессов

Библиотека сайта rus-linux.net

На главную -> MyLDP -> Тематический каталог -> Процессы в Linux Оригинал: Killing With Linux: A Primer Автор: Carla Schroder Дата: 3 августа 2008

Свободный перевод: Алексей Дмитриев

Дата перевода: 8 сентября 2008

Вы усердно боретесь с особо заковыристым приложением Линукс. Продираясь через дебри документации, запускаете команды и правите конфигурационные файлы. Все работает, и жизнь прекрасна… Как вдруг вас ошарашивает сообщение «send the process a SIGHUP» (пошлите процессу SIGHUP).

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

Когда получен сигнал о том, что программа зависла — SIGHUP, sshd перечитывает свой конфигурационный файл путем запуска самой себя с теми же именем и опциями, с которыми была первоначально запущена, например, /usr/sbin/sshd.

Г-м-м. Хорошо.

Программисты против пользователей

Авторы страниц руководств (манов) делятся на две категории. Одни адресуются конечным пользователям, а другие — «крутым» программистам.

Вот почему встречаются заявления типа: «список do будет в работе до тех пор, пока последняя команда в этом списке не выдаст ненулевой выходной статус».

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

Сигналы и контроль над процессами

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

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

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

Команда kill -l выводит список сигналов и их номеров.

Все демоны и процессы имеют Идентификатор Процесса (PID). PID процесса можно узнать при помощи команды ps:

$ ps aux
USER PID %CPU %MEM TTY STAT COMMAND
root 1 0.0 0.1 ? S init '2'
105 7783 0.0 0.2 ? Ss /usr/bin/dbus-daemon —system
hal 7796 0.0 0.7 ? Ss /usr/sbin/hald
postfix 7957 0.0 0.2 ? S qmgr -l -t fifo -u -c
nagios 8371 0.0 0.2 ? SNs /usr/sbin/nagios /etc/nagios/nagios.cfg

В приведенном выше примере, вывод команды сильно сокращен — в вашей системе вы увидите куда больше строк и столбцов. Если какой-нибудь процесс «ворует» мощность вашего процессора или вашу память, вы увидите это в столбцах %CPU и %MEM.

Еще быстрее «зарвавшийся» процесс можно обнаружить при помощи команды top. В ней, по умолчанию, процессы, потребляющие больше ресурсов процессора, расположены в верхних строках таблицы. Мы можем немного поиграть с программой top при помощи команды yes:

$ yes carla is teh awesum

Эта команда станет повторять «carla is teh awesum» с большой скоростью, пока вы ее не остановите. Она загонит процент использования процессора в красную зону:

$ top
… PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
12144 carla 25 0 31592 17m 13m R 93.4 3.5 0:50.26 konsole
22236 carla 15 0 2860 468 400 S 4.3 0.1 0:00.97 yes

Интересно, что ответственность за разбазаривание мощности CPU ложится на консоль, а не на программу yes, так как yes работает внутри консоли. Если вы перейдете на «истинную» консоль (Ctrl+Alt+F2), то там увидите программу yes с большими цифрами потребления мощности процессора и использования памяти.

Существует несколько способов остановить yes. Если вы перейдете обратно в шелл, где она работает, просто нажмите Ctrl+C. Вы можете также остановить ее при помощи команды kill в другом шелле, как по PID, так и по имени:

$ kill 22236
$ killall yes

Ctrl+C посылает с клавиатуры сигнал SIGINT (2), или завершающее прерывание (terminate interrupt). kill и killall, оба, шлют по умолчанию SIGTERM (15). SIGTERM (15) может быть перехвачен и, либо игнорирован, либо интерпретирован иначе. Так что, в случае непредсказуемой работы, вы можете не добиться завершения процесса.

Применяя команду kill к родительскому процессу, вы, как правило (но не всегда), завершаете дочерний вместе с ним. Как узнать, какой процесс является дочерним? Используйте команду ps с опцией -f :

$ ps axf
22371 ? R 2:35 _ konsole 'kdeinit'
22372 pts/3 Ss 0:00 | _ /bin/bash
24322 pts/3 S+ 0:00 | | _ yes carla is teh awesum
22381 pts/4 Rs 0:00 | _ /bin/bash
24323 pts/4 R+ 0:00 | | _ ps axf

Вернемся к нашим SIGHUP'ам

SIGHUP произносится как «сиг-ап» и означает «сигнал отбоя» (signal hangup). Как послать SIGHUP? Существует несколько способов:

  • # kill -HUP 'pid'
  • # killall -HUP 'process-name'
  • # kill -1 'pid'
  • # killall -1 'process-name'
  • Как видите, можно использовать PID или имя процесса, а также имя или номер сигнала.

    Зачем применять все эти команды, когда можно перезапустить процессы при помощи команды /etc/init.

    d/foo restart? Ведь предпочтительней контролировать сервисы с помощью их файлов init, так как такой контроль обычно включает санацию, проверку ошибок и другие функции.

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

    Применение команды kill к процессам

    Как можно видеть в man signal, существуют десятки способов контролировать процессы. Вот наиболее часто применяемые:

    kill -STOP 'pid'
    SIGSTOP (19) останавливает процесс, не «убивая» его.

    kill -CONT 'pid'
    SIGCONT (18) перезапускает остановленный процесс.

    kill -KILL 'pid'
    SIGKILL (9) форсирует немедленное завершение процесса, и не производит никакой чистки.

    kill -9 -1
    Завершает все ваши процессы (которыми вы владеете).

    SIGKILL и SIGSTOP не могут быть перехвачены, блокированы или игнорированы; остальные могут. Это ваше «большое ружье», последнее средство обороны.

    Команда kill, встроенная в Bash

    Оболочка Bash имеет встроенную команду kill, как показано в следующем листинге:

    $ type -all kill kill is a shell built-in kill is /bin/kill

    Маловероятно, что у вас возникнут конфликты или странное поведение программ, но на всякий случай выбирайте /bin/kill.

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

    Ресурсы

    • Глава 7 «Starting and Stopping Linux», Поваренная книга Линукс (the Linux Cookbook)
    • bash (1) — GNU Bourne-Again Shell
    • yes (1) — повторно выводит строку, пока не будет остановлена
    • signal (7) — список сигналов
    • ps (1) — мгновенный снимок идущих процессов
    • kill (1) — посылает сигнал процессу
    • killall (1) — «убивает» процесс по имени
    • pkill (1) — ищет или дает сигнал процессам на основе имени или других атрибутов
    • skill (1) — посылвет сигнал, либо рапортует о статусе процесса
    • xkill (1) — «убивает» клиента по его Х ресурсу
    Читайте также:  Первоначальная настройка ubuntu 16.10

    Если вам понравилась статья, поделитесь ею с друзьями:

    Средняя оценка 5 при 1

    Источник: http://rus-linux.net/lib.php?name=/MyLDP/proc/kill.html

    Команда kill в Unix/Linux

    Сигналы — программные прерывания. Они используются для связи между процессами в UNIX и UNIX-подобных операционных систем, таких как Linux, Mac OS.

    Сигналы использовались еще с Bell Labs UNIX в 1970 и сегодня официально определено стандартом POSIX. Когда сигнал поступает на процесс, операционная система прерывает нормальный поток выполнения процесса и обеспечивает уведомление.

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

    В Unix, Linux, есть команда «kill», которую вы можете использовать, чтобы прекратить процесс немедленно, но и не только это, но об этом немного позже я расскажу.

    В этой статье «Команда kill в Unix/Linux»  я расскажу и покажу на готовых примерах различные команды утилиты  kill.

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

    Когда вы выполняете команду «kill», вы на самом деле посылает е сигнал к системе и даете указание расторгнуть работу некорректной роботы приложения. Существует в общей сложности 60 сигналов, которые можно использовать, но все, что вы действительно должны знать, SIGTERM (15) и SIGKILL (9).

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

    # kill -l

    На моей MacOS:

    kill -l на macos

    На CentOS:

    kill -l на centos

    На Debian:

    kill -l на Debian

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

    Основные сигналы

    Следующие сигналы являются частью стандарта POSIX. Каждый сигнал макрос, определенный в Файл заголовка системы. Они, как правило, сокращенны, без их SIG- префикса; например SIGHUP часто называют просто как HUP.

    SIGTERM –  Этот сигнал запрашивает остановку процесса который работает. Этот сигнал может быть проигнорирован.Процессу дается время, чтобы хорошо выключился. Когда программа хорошо выключается, это означает, что ей дано время, чтобы спасти его прогресс и освободить ресурсы. Другими словами, он не «forced» прекращение работы процесса.

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

    Синтаксис для  «kill».

    Синтаксис команды такой:

    # kill [signal or option] PID(s)

    или

    # kill [-s] [-l] %pid

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

    # kill SIGKILL PID

    Или

    # kill -9 PID

    где «-9» — это флаг относится к сигналу SIGKILL.

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

    $ ps -aux

    А если знаете конкретное приложение (например apache), то можно отсеять ненужное и вывести все процессы по данной службе:

    $ ps -aux | grep apache

    И это отобразит все запущенные приложения вместе с его PID-ом(ами).

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

    # kill -9 3629

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

    # kill -9 PID1 PID2 PID 3

    Перезагурзить конфигурационные файлы или перезапуск утилит:

    # kill -1 number_of_PID

    Особенно полезными сигналы включают HUP, INT, kill, STOP, CONT, и 0.

    Варианты таковы:

    -s signal_name
    Символическое имя сигнала, задающее сигнал для отправки сигнала не по умолчанию.

    -l [exit_status]
    Если операнд не указан,  то показать имена сигналов; В противном случае, написать название сигнала, соответствующего exit_status.

    -signal_name
    Символическое имя сигнала, задающее сигнал для отправки в TERM по умолчанию.

    -signal_number
    Неотрицательное десятичное целое, задающее сигнал для отправки в TERM по умолчанию.

    Следующие PID-ы, имеют особое значение:
    -1 Если суперпользователь, то транслирует сигнал всем процессам;  в противном случае вещает на все процессыbelong-
    ing для пользователя.

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

    • 1 HUP (hang up) — повесить.
    • 2 INT (interrupt) — прерывание.
    • 3 QUIT (quit) — выход.
    • 6 ABRT (abort) — прерывания.
    • 9 KILL (non-catchable, non-ignorable kill)
    • 14 ALRM (alarm clock) — будильник.
    • 15 TERM (software termination signal) — Программное обеспечение для прекращения сигнала.

    PKill

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

    # pkill Firefox

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

    # pkill fire

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

    Pkill команда имеет гораздо больше вариантов, например если указать опцию «-u», то она позволит вам указать имя пользователя или ID. В этом примере мы посылаем сигнал TERM всем процессам, принадлежащие пользователю ‘nobody’:

    # pkill -u nobody

    Killall

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

    # killall firefox

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

    # killall nautilus

    xkill

    Xkill является графическим способом «убить» приложение. При вводе «XKill» в терминале, курсор мыши будет немедленно стать «крест». Все, что вам нужно сделать, это нажать «крест» на провинившихся приложение и он убьет приложение мгновенно. Если вы заинтересованы, вы можете добавить сочетание клавиш для включения функции XKill.

    Еще сигналы которые используются

    SIGABRT

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

    SIGALRM, SIGVTALRM и SIGPROF

    ALRM, VTALRM и / или сигнал PROF отправляется процессу, когда лимит времени, указанный при вызове функции сигнализации (например, setitimer) истекает.

    ALRM

    Посылается, когда настоящее  время или часы с течением времени.

    VTALRM

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

    PROF

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

    SIGBUS

    BUS сигнал посылает процессу, когда это приводит к ошибке шины. Условия, которые приводят к данному сигналу, например, неправильное выравнивание доступа к памяти или отсутствие физического адреса.

    SIGCHLD

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

    SIGCONT

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

    SIGFPE

    Сигнал FPE посылает  процессу, когда он выполняет ошибочное, арифметические срабатывания, например, такие как деление на ноль.

    SIGHUP

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

    SIGILL

    ILL сигнал, посылаемый процессу при попытке выполнить вредоносные, неизвестные или привилегированные команды (инструкции).

    SIGINT

    Сигнал INT посылает процессу от управляющего терминала, когда пользователь желает прервать процесс. Это как правило, инициируется нажатием Control-C, но на некоторых системах, «delete» или «break».

    SIGKILL

    Сигнал KILL посылает процессу чтобы он немедленно прекратил работу. В отличие от SIGTERM и SIGINT этот сигнал не может быть захвачен или проигнорирован и принимающий процесс не может выполнить какие-либо очистку после получения этого сигнала.

    SIGPIPE

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

    SIGQUIT

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

    SIGSEGV

    Сигнал SEGV отправляется в процесс, когда он делает недопустимую ссылку виртуальной памяти или сбой сегментации, то есть когда он выполняет нарушение сегментации.

    SIGSTOP

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

    SIGTERM

    Сигнал TERM посылается в процесс чтобы запросить о его прекращении. В отличие от сигнала «kill», он может быть и интерпретируемым или игнорируемым в процессе. Это позволяет процессу выполнять «nice» выполнение для прекращения высвобождения ресурсов и сохранения состояния в случае необходимости. Следует отметить, что SIGINT почти идентичен SIGTERM.

    SIGTSTP

    Сигнал TSTP посылается в процесс его управляющего терминала и говорит ему, что нужно временно приостановить. Это обычно инициируется пользователем нажатием Control-Z. В отличие от SIGSTOP, этот процесс может зарегистрировать обработчик сигнала или чтобы игнорировать сигнал.

    SIGTTIN и SIGTTOU 

    В TTIN и TTOU сигналы посылаются процессу, когда он пытается прочитать или записать соответственно с (tty) терминала на заднем плане. Как правило, этот сигнал может быть получен только с помощью процессов находящихся под контролем рабочей панели; демоны не имеют управляющие терминалы и никогда не должны получать этот сигнал.

    SIGUSR1 и SIGUSR2

    Сигналы USR1 и USR2 отправляются процессу и указывают определенные пользователем условия.

    SIGPOLL

    Сигнал POLL отправляется в процессе, когда происходит асинхронное событие ввода / вывода.

    SIGSYS

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

    SIGTRAP

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

    SIGURG

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

    SIGXCPU

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

    SIGXFSZ

    Сигнал XFSZ отправляется в процессе, когда файл вырастает (превышает заданное значение), чем максимально допустимое значение.

    SIGRTMIN to SIGRTMAX

    Сигналы RTMIN — RTMAX предназначены для использования в пользовательских целей. Они сигналы реального времени.

    Разные сигналы

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

    SIGEMT

    Сигнал ЕМТ отправляется в процессе, когда происходит прерывание эмулятора.

    SIGINFO

    Сигнал INFO отправляется в процессе, когда запрос статуса получен от управляющего терминала.

    SIGPWR

    Сигнал PWR отправляется в процессе, когда система испытывает сбой питания.

    SIGLOST

    LOST сигнал посылается к процессу, когда «file lock» теряется.

    SIGWINCH

    Сигнал WINCH отправляется в процессе, когда его управляющий терминал меняет свой размер.

    Отправка сигналов с клавиатуры

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

    CTRL-C

    Отправить SIGINT (прерывание). По умолчанию это вызывает процесс прекращается.

    CTRL-Z

    Отправить SIGTSTP (Suspend). По умолчанию это вызывает процесс приостановить все операции.

    CTRL-

    Отправить SIGQUIT (Quit). По умолчанию это вызывает процесс прекратить немедленно и сбросить ядро.

    CTRL-T

    Отправить SIGINFO (INFO). По умолчанию это заставляет операционную систему отображать информацию о команде. Не поддерживается на всех системах.

    вывод

    Когда приложения ведут себя неправильно и вызвают к зависанию системы, это очень заманчиво, чтобы перезагрузить компьютер и начать сеанс снова и снова. С помощью этих команд «kill», вы сможете лучше управлять плохим поведением приложений которые вызывают или могут вызвать крах системы. На этом, я завершаю данную тему «Команда kill в Unix/Linux».

    Источник: http://linux-notes.org/komanda-kill-v-unix-linux/

    Ссылка на основную публикацию