Как и любая другая многозадачная система, Linux одновременно выполняет несколько процессов. Вообще, не буду вводить Вас в заблуждение, потому что обычный однопроцессорный компьютер может выполнять только одну задачу в данный момент времени, по-этому Linux ставит процессы в очередь на выполнения.
Существует несколько основных команд для управлением процессами
Хотя может показаться, что эти знания достаточно абстрактны, но они могут найти свое практическое применение даже для среднего пользователя, который использует графический интерфейс. Возможно Вы еще не знаете, что большинство графических программ (если не все) можно запустить при помощи командной строки. Для примера попробуем запустить браузер, думаю у большинства linux-оидов стоит или Google Chrome или FireFox
Enej@linux:/home/pub/www/vv$ google-chrome Created new window in existing browser session.
Можно указать URL, который Вы хотите открыть
Enej@linux:/home/pub/www/vv$ google-chrome http://сайт Created new window in existing browser session.
У меня уже запущен Хром через графический интерфейс, по-этому браузер сообщает, что создается новое окно в существующей сессии и отдает управление командной строке. Или, например, если нужно открыть графический файловый менеджер с правами рута (пример будет работать для графической оболочки Gnome с установленным Nautilus)
Enej@linux:/home/pub/www/vv$ sudo nautilus /root/ password for enej:
Поскольку процесс был запущен не в фоновом режиме, то в этом окне терминала Вы больше не можете выполнять какие-либо действия (чтобы завершить процесс можно нажать CTRL + C).
Для того, чтобы было проще жить, при запуске графических программ или процессов, которые могут долго работать, обычно их выполнение ставят в фоновый режим, например, давайте запустим браузер в фоновом режиме
Enej@linux:/home/pub/www/vv$ google-chrome http://сайт & 9248
Знак амперсанта (& ) в конце вызова команды значит, что выполнение процесса нужно поместить в фоновый режим. В таком случае, остается возможность работать с даным окном терминала.
Но вдруг Вы забыли поставить ампресант в конце вызова, тогда существует другой способ. Нужно сначала остановить выполнение нажав CTRL + Z, тогда получаем управление командной строкой и можем вызвать команду bg , которая поставим последний запущенный процесс в фоновый режим. Сказанное на примере
Enej@linux:/home/pub/www/vv$ google-chrome http://сайт ^Z + Stopped google-chrome http://сайт enej@linux:/home/pub/www/vv$ bg + google-chrome http://сайт &
Команда fg выводит последний запущенный процесс из фонового режима.
Поскольку теперь Вы умеете ставить команды в фоновый режим, было хорошо посмотреть их список. Для этого используется команда jobs или более мощная ps
Enej@linux:/home/pub/www/vv$ jobs - Running nm-applet & (wd: ~/bin) + Running google-chrome http://сайт & enej@linux:/home/pub/www/vv$ ps PID TTY TIME CMD 2304 pts/0 00:00:02 bash 11104 pts/0 00:00:01 chrome 11108 pts/0 00:00:00 chrome 11110 pts/0 00:00:00 chrome 11132 pts/0 00:00:00 chrome 12088 pts/0 00:00:00 ps 21165 pts/0 00:00:27 nm-applet
Если процесс перестает отвечать на действия (т.е. завис), его нужно принудительно "убить". Думаю те кто использует FireFox сталкивались с этим. Для таких задач используется команда kill . Но для начала нужно каким-то образом определить процесс. Для этого можно использовать команду jobs или ps . С помощью первой можно узнать номер процесса, с помощью второй его идентификатор.
Enej@linux:/home/pub/www/vv$ google-chrome http://freaksidea..com & 15181 enej@linux:/home/pub/www/vv$ ps PID TTY TIME CMD 2304 pts/0 00:00:02 bash 15181 pts/0 00:00:00 chrome 15238 pts/0 00:00:00 ps 21165 pts/0 00:00:27 nm-applet enej@linux:/home/pub/www/vv$ kill 15181
Команды fg и bg в качестве первого аргумента могут принимать номер запущеного процесса, для его последуещего ввода/вывода в/из фонового режима.
На самом деле команда kill используется для отправки разных сигналов процессам. Просто в большинстве случаев этот сигнал говорит команде, что она должна завершится. Если программы правильно написаны, то они прослушивают различные сигналы от операционной системы и отвечают на них. Например, текстовый редактор должен прослушивать любой сигнал, который уведомляет, что пользователей выходит из системы или что компьютер выключается. Когда он (текстовый редактор) "услышал" такой сигнал, он должен сохранить открытые документы перед тем как закончить свою работу. Команда kill умеет отсылать несколько типов сигналов, чтобы узнать какие, введите kill -l . Ниже приведен список самых часто используемых сигналов (число в скобках - номер сигнала)
По умолчанию команда kill отправляет SIGTERM сигнал, но также можно указать номер сигнала или его имя. Допустим, что у Вас завис Chrome (у меня иногда флэш плеер перестает адекватно работать)
Enej@linux:/home/pub/www/vv$ google-chrome http://сайт & 22066 enej@linux:/home/pub/www/vv$ jobs - Running nm-applet & (wd: ~/bin) + Running google-chrome http://сайт & enej@linux:/home/pub/www/vv$ kill -SIGTERM %2 enej@linux:/home/pub/www/vv$ kill -SIGKILL %2 enej@linux:/home/pub/www/vv$ kill -9 %2
P.S. : думаю очень интересным для начинающих будет 2 команды: notify-send (отправляет сообщение через графическую оболочку, в Gnome появляется вверху справа) и espeak (синтезатор речи). Если какой-то из них у Вас нет, установить можно при помощи команды apt-get
Enej@linux:/home/pub/www/vv$ sudo apt-get install espeak notify-send
Тогда вам в обязательном порядке нужно знать о screen .
Screen в linux — это как "окна в Windows", которые можно свернуть/развернуть. Вы можете что то делать в одном окне, например смотреть фотографии. Но, если вам нужно кроме просмотра фотографий слушать музыку, то вы откроете новое окно (проводник), зайдёте в каталог с музыкой и отроете песню в аудио-программе.
Когда речь идёт о консоли линукс (особенно при работе по ssh ), то нам будет крайне не удобно в одной консоли выполнять различные приложения. А, может, и совсем не удастся выполнять вторую операцию в то время, когда первая ещё продолжает свою работу. Это первый момент. Второй момент заключается в том, что в случае какого-либо сбоя с вашей стороны (со стороны клиента) - текущая операция прервётся. Пара примеров, когда при работе с ssh может понадобиться screen :
Наверное, вам было бы очень грустно, когда из-за случайно-закрытого терминала или скачка напряжения прервался бы sql-запрос, который уже выполнялся более 10 часов. В случае же с screen, screen работает на сервере, инициатором запроса будет объект screen и запрос уже не оборвётся не при каких проблемах клиента. При обрыве связи процессы не останавливаются, а продолжают работать, и к ним можно вернуться в любой момент.
Для создания screen и начала работы с ним напечатайте в командной строке:
где test1 - произвольное имя для объекта screen, вы можете назвать его для удобства как вам нравится.
При этом будет создан screen под именем test1 . Теперь вы можете запускать любые долгие операции. Например выполнять sql-запрос:
Mysql -u ... select * from ... update ...
Уже на этом этапе, если у вас пропадёт интернет, вы случайно закроете вкладку терминала, перезагрузится комьютер — вы не потеряете никаких данных и sql-запрос не прервётся.
Чтобы выйти из screen, нажмите следующие клавиши:
Чтобы вернуться в ваш screen либо в любое другое окно screen, можно просмотреть все доступные screen:
screen -r
Когда сессия screen вам больше не нужна, чтобы полностью завершить сессию скрин, активируйте screen с помощью screen -r
Администрирование сервера под управлением Linux довольно часто сопровождается множественными манипуляциями команд в окне терминала. Это привычная картина для тех, кто администрирует сервера на Linux, и в некоторых случаях удобно выполнять команды в фоновом режиме. Это вполне может быть использовано на практике, и стоит отметить причины, почему это может быть полезным:
— Когда терминал переполняется кучей сообщений, да и выполнять параллельно дополнительные действия не представляется возможным;
— Если вы закрываете терминал, то останавливается текущий процесс, с его дочерними процессами;
Данные проблемы решаются элементарно, говоря простым языком нам необходимо полностью отделить выполняемый процесс от управляющего терминала.
В данном посту мы рассмотрим полезную возможность Linux выполнения команд в фоновом режиме. Иными словами процесс запущенный вами будет выполняться отдельно от управляющего терминала.
Как запускать команды или процессы в фоновом режиме
Если ваш процесс запущен в окне терминала, то приостановить его можно с помощью команды Ctrl+Z
, наверное, это многие знают, и подумают, и что с этого. И вот что интересное, приостановив, таким образом, процесс, мы можем продолжить его в фоновом режиме, для этого необходимо ввести команду
После ввода этой команды процесс будет продолжен, но уже в фоновом режиме. Чтобы просмотреть все процессы, выполняемые в фоновом режиме, вы можете ввести команду
Давайте просмотрим простой пример, как это можно применить. Предположим у нас есть , который нам необходимо распаковать, однако нам некогда ждать, и мы хотим работать параллельно.
Распаковка архива в фоновом режиме
$ tar -czf home.tar.gz .
Жмем Cntr+Z , затем вводим команды
$ bg $ jobs
Второй способ – это добавить символ & в конце команды, это сообщит системе, что нужно выполнять команду в фоновом режиме.
$ tar -czf home.tar.gz . & $ jobs
Подобный способ позволяет выполнять процессы в фоновом режиме, тем не менее, STDIN , STDOUT , STDERR всё ещё связаны с терминалом. Теперь давайте добьемся того, чтобы процесс выполнялся даже при закрытии терминала.
Выполнение процесса после закрытия окна терминала
Чтобы процесс продолжил работать даже после закрытия окна терминала, мы можем использовать команду disown
. Она «отцепит» процесс от оболочки окна терминала, после чего будет выполняться даже после закрытия окна консоли.
Давайте рассмотрим пример использования стандартной команды rsync
, попробуем выполнить ее в фоновом режиме, и отцепим процесс от терминала.
$ sudo rsync Templates/* /var/www/html/ & $ jobs $ disown -h %1 $ jobs
Вы так же можете использовать команду nohup , она позволит продолжить выполнение процесса даже когда пользователь выходит из оболочки системы.
$ nohup tar -czf iso.tar.gz Templates/* & $ jobs
Как отделить процесс от управляющего терминала Linux
Чтобы полностью отделить процесс от управляющего терминала, можно так же использовать команду, которая будет эффективной при использовании пользовательского графического интерфейса (GUI), к примеру, браузер Firefox.
$ firefox /dev/null &
В системе Linux (да и практически во всех Unix-системах) /dev/null представляет собой специальный файл устройства, которое так же называют «пустым устройством». Запись в него производиться успешно вне зависимости от объема записанной информации, чтение из него эквивалентно считыванию конца файла (EOF).
В прошлый раз мы говорили о работе с потоками ввода, вывода и ошибок в bash-скриптах, о дескрипторах файлов и о перенаправлении потоков. Сейчас вы знаете уже достаточно много для того, чтобы писать что-то своё. На данном этапе освоения bash у вас вполне могут возникнуть вопросы о том, как управлять работающими скриптами, как автоматизировать их запуск.
До сих пор мы вводили имена скриптов в командную строку и нажимали Enter, что приводило к немедленному запуску программ, но это - не единственный способ вызова сценариев. Сегодня мы поговорим о том как скрипт может работать с сигналами Linux, о различных подходах к запуску скриптов и к управлению ими во время работы.
| Код сигнала
|
Название
|
Описание
|
| 1 |
SIGHUP |
Закрытие терминала |
| 2 |
SIGINT |
Сигнал остановки процесса пользователем с терминала (CTRL + C) |
| 3 |
SIGQUIT |
Сигнал остановки процесса пользователем с терминала (CTRL + \) с дампом памяти |
| 9 |
SIGKILL |
Безусловное завершение процесса |
| 15 |
SIGTERM |
Сигнал запроса завершения процесса |
| 17 |
SIGSTOP |
Принудительная приостановка выполнения процесса, но не завершение его работы |
| 18 |
SIGTSTP |
Приостановка процесса с терминала (CTRL + Z), но не завершение работы |
| 19 |
SIGCONT |
Продолжение выполнения ранее остановленного процесса |
Сигнал SIGINT приводит к временной остановке работы. Ядро Linux перестаёт выделять оболочке процессорное время. Когда это происходит, оболочка уведомляет процессы, отправляя им сигнал SIGINT .
Bash-скрипты не контролируют эти сигналы, но они могут распознавать их и выполнять некие команды для подготовки скрипта к последствиям, вызываемым сигналами.
Выполним в оболочке такую команду:
$ sleep 100
После этого завершим её работу комбинацией клавиш CTRL + C .
$ sleep 100
И временно остановим её комбинацией клавиш CTRL + Z .
Число в квадратных скобках - это номер задания, который оболочка назначает процессу. Оболочка рассматривает процессы, выполняющиеся в ней, как задания с уникальными номерами. Первому процессу назначается номер 1, второму - 2, и так далее.
Если вы приостановите задание, привязанное к оболочке, и попытаетесь выйти из неё, bash выдаст предупреждение.
Просмотреть приостановленные задания можно такой командой:
Ps –l
В колонке S , выводящей состояние процесса, для приостановленных процессов выводится T . Это указывает на то, что команда либо приостановлена, либо находится в состоянии трассировки.
Если нужно завершить работу приостановленного процесса, можно воспользоваться командой kill . Подробности о ней можно почитать .
Выглядит её вызов так:
Kill processID
Команда trap позволяет скрипту реагировать на сигналы, в противном случае их обработка выполняется оболочкой без его участия.
Рассмотрим пример, в котором показано, как при вызове команды trap задаётся код, который надо выполнить, и список сигналов, разделённых пробелами, которые мы хотим перехватить. В данном случае это всего один сигнал:
#!/bin/bash
trap "echo " Trapped Ctrl-C"" SIGINT
echo This is a test script
count=1
while [ $count -le 10 ]
do
echo "Loop #$count"
sleep 1
count=$(($count + 1))
done
Команда trap , использованная в этом примере, выводит текстовое сообщение всякий раз, когда она обнаруживает сигнал SIGINT , который можно сгенерировать, нажав Ctrl + C на клавиатуре.
Каждый раз, когда вы нажимаете клавиши CTRL + C , скрипт выполняет команду echo , указанную при вызове trace вместо того, чтобы позволить оболочке завершит его работу.
Перехватить сигнал выхода из скрипта можно, использовав при вызове команды trap имя сигнала EXIT: #!/bin/bash
trap "echo Goodbye..." EXIT
count=1
while [ $count -le 5 ]
do
echo "Loop #$count"
sleep 1
count=$(($count + 1))
done
При выходе из скрипта, будь то нормальное завершение его работы или завершение, вызванное сигналом SIGINT , сработает перехват и оболочка исполнит команду echo .
#!/bin/bash
trap "echo "Ctrl-C is trapped."" SIGINT
count=1
while [ $count -le 5 ]
do
echo "Loop #$count"
sleep 1
count=$(($count + 1))
done
trap "echo " I modified the trap!"" SIGINT
count=1
while [ $count -le 5 ]
do
echo "Second Loop #$count"
sleep 1
count=$(($count + 1))
done
После модификации сигналы будут обрабатываться по-новому.
Перехват сигналов можно и отменить, для этого достаточно выполнить команду trap , передав ей двойное тире и имя сигнала:
#!/bin/bash
trap "echo "Ctrl-C is trapped."" SIGINT
count=1
while [ $count -le 5 ]
do
echo "Loop #$count"
sleep 1
count=$(($count + 1))
done
trap -- SIGINT
echo "I just removed the trap"
count=1
while [ $count -le 5 ]
do
echo "Second Loop #$count"
sleep 1
count=$(($count + 1))
done
Если скрипт получит сигнал до отмены перехвата, он обработает его так, как задано в действующей команде trap . Запустим скрипт:
$ ./myscript
И нажмём CTRL + C на клавиатуре.
Первое нажатие CTRL + C пришлось на момент исполнения скрипта, когда перехват сигнала был в силе, поэтому скрипт исполнил назначенную сигналу команду echo . После того, как исполнение дошло до команды отмены перехвата, команда CTRL + C сработала обычным образом, завершив работу скрипта.
Если вы видели список процессов, выводимый командой ps , вы могли заметить процессы, которые выполняются в фоне и не привязаны к терминалу.
Напишем такой скрипт:
#!/bin/bash
count=1
while [ $count -le 10 ]
do
sleep 1
count=$(($count + 1))
done
Запустим его, указав после имени символ амперсанда (&):
$ ./myscipt &
Это приведёт к тому, что он будет запущен как фоновый процесс.
Скрипт будет запущен в фоновом процессе, в терминал выведется его идентификатор, а когда его выполнение завершится, вы увидите сообщение об этом.
Обратите внимание на то, что хотя скрипт выполняется в фоне, он продолжает использовать терминал для вывода сообщений в STDOUT и STDERR , то есть, выводимый им текст или сообщения об ошибках можно будет увидеть в терминале.
При таком подходе, если выйти из терминала, скрипт, выполняющийся в фоне, так же завершит работу.
Что если нужно, чтобы скрипт продолжал работать и после закрытия терминала?
Применим эту методику при запуске нашего скрипта:
Nohup ./myscript &
Вот что будет выведено в терминал.
Команда nohup отвязывает процесс от терминала. Это означает, что процесс потеряет ссылки на STDOUT и STDERR . Для того, чтобы не потерять данные, выводимые скриптом, nohup автоматически перенаправляет сообщения, поступающие в STDOUT и в STDERR , в файл nohup.out .
Обратите внимание на то, что при запуске нескольких скриптов из одной и той же директории то, что они выводят, попадёт в один файл nohup.out .
#!/bin/bash
count=1
while [ $count -le 10 ]
do
echo "Loop #$count"
sleep 10
count=$(($count + 1))
done
Запустим его:
$ ./myscript
И временно остановим комбинацией клавиш CTRL + Z .
Запустим тот же скрипт в фоновом режиме, при этом перенаправим вывод скрипта в файл так, чтобы он ничего не выводил на экране:
$ ./myscript > outfile &
Выполнив теперь команду jobs , мы увидим сведения как о приостановленном скрипте, так и о том, который работает в фоне.
Ключ -l при вызове команды jobs указывает на то, что нам нужны сведения об ID процессов.
Запустим скрипт:
$ ./myscript
Нажмём CTRL + Z , что временно остановит его выполнение. Выполним следующую команду:
$ bg
Теперь скрипт выполняется в фоновом режиме.
Если у вас имеется несколько приостановленных заданий, для перезапуска конкретного задания команде bg можно передать его номер.
Для перезапуска задания в обычном режиме воспользуйтесь командой fg:
Вызов команды at выглядит так:
At [-f filename] time
Эта команда распознаёт множество форматов указания времени.
$ at -f ./myscript now
Ключ -M при вызове at используется для отправки того, что выведет скрипт, по электронной почте, если система соответствующим образом настроена. Если отправка электронного письма невозможна, этот ключ просто подавит вывод.
Для того чтобы посмотреть список заданий, ожидающих выполнения, можно воспользоваться командой atq:
$ atrm 18
В Linux имеется утилита crontab , позволяющая планировать запуск скриптов, которые нужно выполнять регулярно.
Crontab выполняется в фоне и, основываясь на данных в так называемых cron-таблицах, запускает задания по расписанию.
Для того, чтобы просмотреть существующую таблицу заданий cron , воспользуйтесь такой командой:
$ crontab –l
При планировании запуска скрипта по расписанию crontab принимает данные о том, когда нужно выполнить задание, в таком формате:
Минута, час, день месяца, месяц, день недели.
Например, если надо, чтобы некий скрипт с именем command выполнялся ежедневно в 10:30, этому будет соответствовать такая запись в таблице заданий:
30 10 * * * command
Здесь универсальный символ « * », использованный для полей, задающих день месяца, месяц и день недели, указывает на то, что cron должен выполнять команду каждый день каждого месяца в 10:30.
Если, например, надо, чтобы скрипт запускался в 4:30PM каждый понедельник, понадобится создать в таблице заданий такую запись:
30 16 * * 1 command
Нумерация дней недели начинается с 0, 0 означает воскресенье, 6 - субботу. Вот ещё один пример. Здесь команда будет выполняться в 12 часов дня в первый день каждого месяца.
00 12 1 * * command
Нумерация месяцев начинается с 1.
Для того чтобы добавить запись в таблицу, нужно вызвать crontab с ключом -e:
Crontab –e
Затем можно вводить команды формирования расписания:
30 10 * * * /home/likegeeks/Desktop/myscript
Благодаря этой команде скрипт будет вызываться ежедневно в 10:30. Если вы столкнётесь с ошибкой «Resource temporarily unavailable», выполните нижеприведённую команду с правами root-пользователя:
$ rm -f /var/run/crond.pid
Организовать периодический запуск скриптов с использованием cron можно ещё проще, воспользовавшись несколькими специальными директориями:
/etc/cron.hourly
/etc/cron.daily
/etc/cron.weekly
/etc/cron.monthly
Если поместить файл скрипта в одну из них, это приведёт, соответственно, к его ежечасному, ежедневному, еженедельному или ежемесячному запуску.
$HOME/.bash_profile
$HOME/.bash_login
$HOME/.profile
Для того, чтобы запускать скрипт при входе в систему, поместите его вызов в файл.bash_profile .
А как насчёт запуска скриптов при открытии терминала? Организовать это поможет файл.bashrc .
Уважаемые читатели! А вы пользуетесь средствами планирования запуска сценариев командной строки по расписанию? Если да - расскажите пожалуйста о них.
Задания и процессы
Всякая выполняющаяся в 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 являются внутренними командами оболочки. Если, по некоторой причине, вы используете командную оболочку, которая не поддерживает функции управления заданиями, то вы в ней этих (и подобных) команд не отыщете.
