Сигналы

NICE-фактор

Синтаксис команды простой: через ключ -n мы передаем значение приращения nice-фактора, а затем идет команда для которой будет устанавливаться новый nice-фактор. Речь идет именно о приращении, так как реальный nice-фактор нового процесса будет равен nice-фактору родительского процесса сложенному с числом передаваемым команде nice. В приведенном выше примере nice-фактор родительского процесса (оболочки bash) равен нулю, значит nice-фактор дочернего будет 0+5=5, что мы и видим на результатах.

Обычные пользователи могут только увеличиватьnice-фактор, но не могут его уменьшать. Сделано это для того, чтобы пользователи не смогли создавать высокоприоритетные процессы. Если от имени пользователя выполнить команду nice -n -5 sleep 30 &, получим сообщение об ошибке. Уменьшать nice-фактор может только пользователь root.

Если необходимо изменить nice-фактор уже запущенного процесса, то используют команду renice. Например:

$ renice 14 13229
13229: старый приоритет 10, новый приоритет 14

где 13229 это PID процесса для которого меняется nice-фактор. Из примера, также видно, что число 14 это уже не приращение, а просто новое значение nice-фактора.

Для каких практических целей можно использовать nice-фактор? Например, если какие-то процессы занимают в данный момент большое количество процессорного времени, то для более быстрого определения проблемы можно запустить интерпретатор команд с более низким nice-фактором. Операции разного рода кодирования или сжатия, которые требуют много времени (часы), можно запускать с более высоким nice-фактором, чтобы не загружать систему. Быстродействие современных процессоров, таково, что к изменению nice-фактора прибегают все реже, но тем не менее иногда он может быть очень полезен.

В этом примере процесс less взаимодействует с процессом grep посредством механизма, который называется неименований канал или пайп (pipe - канал). Мы не будем вдаваться в подробности, просто запомните, что посредством символа |, который можно в данном случае называть “пайпом” информация (результат выполнения) процесса less идет на вход другого процесса - grep. Таким образом один процесс передал информацию другому процессу.

Еще один способ общения процессов - это именованные каналы. Именованный канал можно создать командой mkfifo:

$ mkfifo my_pipe
$ ls -l | grep my_pipe
prw-r–r– 1 igor igor 0 2009-11-09 17:59 my_pipe

Теперь в одной консоли выполните команду:

$ echo Hello > my_pipe

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

$ cat my_pipe
Hello

Если вернуться на первую консоль, то вы увидите, что команда echo завершила свою работу. Таким образом через именованный канал my_pipe команда (процесс) echo передала информацию (слово Hello) процессу cat, который ее принял и вывел на экран.

Задание 3. Изменить приоритет пользовательского процесса.

7. Сигналы.

Давайте теперь рассмотрим основной способ “общения” процессов - сигналы. Один процесс при помощи ядра может передать другому процессу специальное числовое значение сигнала. Процесс вызывает функцию передачи сигнала и передает необходимую информацию (код сигнала, PID процесса) ядру. Ядро передает сигнал процессу получателю и отслеживает как этот сигнал обрабатывается. Сигналы обозначаются цифрами или мнемоническими обозначениями. Перечень сигналов можно вывести командой kill -l.

Мнемонические имена которые вы видите (SIGTERM, SIGINT, SIGKILL) начинаются с приставки SIG. Имена в этом виде используются в языках программирования таких как С. В интерпретаторе bash используются или числа или мнемонические имена, но без приставки SIG - TERM, INT, KILL.

Часть сигналов (INT, TERM) являются перехватываемыми. Это означает, что процесс при получении такого сигнала должен перейти на специальную подпрограмму, которая занимается обработкой сигнала. Если подпрограммы обработки нет (а ее написанием занимаются разработчики программы, которая выполняется в контексте процесса), то управление передается ядру, которое выполняет действия по умолчанию, описанные для каждого сигнала.

Часть сигналов являются такими которые можно заблокировать. Например, один процесс посылает сигнал TERM другому процессу, а он в свою очередь не закончил операции ввода/вывода. В таком случае второй процесс может заблокировать полученный сигнал (опять таки в обработчике сигнала) до момента выполнения необходимой операции ввода/вывода. Сигнал TERM - это сигнал корректного завершения работы процесса. Обработчик этого сигнала, должен выполнить все необходимые действия для правильного завершения работы.

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

Пока мы говорили о том как процессы “общаются” между собой с помощью сигналов. Но мы (пользователи) также можем посылать сигналы процессам. Например, комбинация клавиш Ctrl+C посылает процессу сигнал INT, который прерывает выполнение процесса. Если вы наберете в терминале команду sleep 100, то команда не вернет управление терминалу пока не завершится. Прервать выполнение этой команды можно нажав комбинацию клавиш Ctrl+C.

В чем же отличия между похожими сигналами INT, TERM, KILL (а также QUIT и HUP)? Несмотря на похожесть отличия есть:

Сигнал KILL не блокируется и не перехватывается и ведет к немедленному завершению процесса.
Сигнал INT в отличии от KILL является блокируемым сигналом и перехватываемым.
Сигнал TERM также является перехватываемым и блокируемым и предназначен для корректного (предпочтительного) завершения работы процесса.
Сигнал QUIT - похож на TERM, но позволяет сохранить дамп памяти.
Сигнал HUP - сейчас этот сигнал чаще всего интерпретируется процессами как “прочесть конфигурационные файлы”.

Рассмотрим два сигнала: STOP и CONT. Сигнал STOP останавливает процесс, то есть процесс переходит в состояние “ остановленный “. В таком состоянии процесс будет до тех пор пока снова не получит сигнал. Если будет получен сигнал CONT, то процесс возобновит свою работу с того момента как он был остановлен. Практический пример:

Задание 4.

1. Наберите в терминале команду sleep 1000 &.

Затем проверьте, что процесс находится в состоянии ожидания, о чем нам говорит буква S в столбце S:

$ top | grep [s]leep
PID S TIME COMMAND
6301 S 0:00 sleep 1000

2. Теперь пошлем процессу сигнал STOP. Для этого используем команду kill (kill -название процесса PID процесса):

$ kill -STOP 6301
[1]+ Stopped sleep 1000

3. Проверяем статус процесса:

$ top | grep [s]leep
PID S TIME COMMAND
6301 T 0:00 sleep 1000

Видим, что процесс действительно находится в состоянии “остановленный” (символ T в столбце S).

4. Теперь отправим процессу сигнал продолжения работы (CONT) и проверим состояние:

kill -CONT 6301
$ top | grep [s]leep
PID S TIME COMMAND
6301 S 0:00 sleep 1000

5. Если необходимо корректно завершить процесс, то необходимо послать ему сигнал TERM:

$ kill -TERM 6301
$ top | grep [s]leep
[1]+ Terminated sleep 1000
$ top | grep [s]leep

6. Если сразу же после посылки сигнала TERM выполнить команду top x | grep [s]leep, то можно успеть увидеть сообщение о том, что процесс завершает работу, в при следующей попытке вывести информацию о нашем процессе sleep мы уже ничего не увидим - процесс прекратил существование. Команда kill без указания сигнала, по умолчанию передает процессу именно сигнал TERM. Поэтому можно было написать просто kill 6301.

7. Если необходимо срочно завершить процесс, или процесс не завершается по сигналу TERM, то тогда необходимо послать процессу сигнал KILL:

$ sleep 1000 &
[1] 6348
$ kill -KILL 6348
$ top | grep [s]leep
[1]+ Killed sleep 1000

8. Если необходимо послать один и тот же сигнал нескольким процессам, то можно перечислить их через пробел: kill -TERM 2345 3456 4567.

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

9. Запустите несколько раз подряд команду sleep 1000 &:

$ top | grep [s]leep
6460 S 0:00 sleep 1000
6461 S 0:00 sleep 1000
6462 S 0:00 sleep 1000
6463 S 0:00 sleep 1000
6464 S 0:00 sleep 1000
6465 S 0:00 sleep 1000
6466 S 0:00 sleep 1000

10. Теперь, чтобы завершить все процессы с именем sleep, достаточно набрать команду killall sleep:

$ killall sleep
[1] Terminated sleep 1000
[2] Terminated sleep 1000
[3] Terminated sleep 1000
[4] Terminated sleep 1000
[6]- Terminated sleep 1000
[7]+ Terminated sleep 1000
[5]+ Terminated sleep 1000

11. Выполните команду sleep 1000 & еще несколько раз, а затем зарегистрируйтесь в другой консоли от имени другого пользователя (например, test) и также от его имени выполните команду sleep 1000 &. Теперь вернитесь в свою консоль и просмотрите процессы sleep всех пользователей:

$ top | grep [s]leep
igor 6540 0.0 0.0 2952 628 S 22:30 0:00 sleep 1000
igor 6541 0.0 0.0 2952 632 S 22:30 0:00 sleep 1000
igor 6542 0.0 0.0 2952 628 S 22:30 0:00 sleep 1000
test 6543 0.0 0.0 2952 632 S 22:30 0:00 sleep 1000
test 6544 0.0 0.0 2952 628 S 22:30 0:00 sleep 1000
test 6545 0.0 0.0 2952 628 S 22:30 0:00 sleep 1000
test 6546 0.0 0.0 2952 632 S 22:30 0:00 sleep 1000

Дата добавления: 2014-10-23