Служба с терминалом Linux по умолчанию ведется в однозадачном режиме. Это означает, что любая запущенная бригада блокирует терминал до своего завершения. Такой подход не удобен при запуске программ, спрашивающих продолжительного времени выполнения. Данную проблему можно решить двумя способами: раскрыть дополнительное окно терминала и выполнить в нем другую команду или использовать фоновый режим. Все нынешние операционные системы, в том числе и Linux, являются многозадачными, что подразумевает под собой возможность синхронного выполнения множества программ.
Как запустить бригаду в фоновом режиме, чтобы сразу получить доступ к интерфейсу командной строки? Бригада, выполнение которой было запланировано принудительно, называется фоновым процессом. Фоновые процессы не показываются на экране. Например, HTTPD-сервер Apache работает в фоновом режиме для обслуживания веб-страниц. В низкоприоритетный режим можно поместить скрипт оболочки или любую команду. Задачу (например, бригаду или скрипт) можно перевести в фоновый режим, добавив символ «&» в конец командной строчки. Этот оператор переводит команду в фоновый режим и освобождает место в терминале. Бригада, выполняемая в фоновом режиме, называется заданием. Во время работы фоновой команды возможно выполнять любые другие команды. Синтаксис выглядит следующим образом:
command & script-name & /path/to/command arg1 arg2 & command-1 | command-2 arg1 & command-1 | command-2 -arg1 -arg2 >/path/to/output &
Для пуска программ в фоновом режиме, не блокирующем окно терминала, необходимо использовать специальный инструктор «&». Поставьте этот символ в самом конце строки после указания фамилии команды, опций и входящих параметров. В общем виде данную последовательность можно вписать как «имя_команды -опция входящий_параметр &».
ls ~/* > ~/test-file.txt &
18960
После нажатия кнопки Enter программа автоматически запустится в фоновом режиме. При этом терминал покажет строчку со следующим содержимым «[номер_задания] идентификатор_процесса», и выдаст приглашение к вводу новоиспеченной команды.
Найти команды, работающие в фоновом режиме в Linux
Выполните следующую бригаду:
Пример вывода данных:
Running find / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ Running grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &
Где и идентификаторы поручений.
Чтобы отобразить идентификаторы процессов для идентификаторов заданий помимо стандартных приведений, передайте параметр -l:
Пример вывода данных:
7307 Running find / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ 7324 Running grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &
Дабы отобразить только идентификаторы процессов, введите:
Пример вывода данных:
Кончить выполнение команд, работающих в фоновом режиме
Для принудительного или постепенного завершения процесса вытечет использовать команду kill. Синтаксис выглядит следующим образом:
kill PID
kill -15 PID
kill -9 PID
killall process-Name-Here
killall -15 process-Name-Here
killall -9 process-Name-Here
Возврат програмки в приоритетный режим в Linux
Linux позволяет не только запускать программы в фоновом режиме, но и по хотению возвращать к привычному выполнению. Для этого существует два инструмента: команда (Команда - группа лиц, объединённая общими мотивами, интересами ) fg и оператор %. Принцип их усилия предельно прост. fg требует указать номер задания в качестве параметра, а к % его нужно подставить сходу после оператора без пробелов.
find / -name .ini 2> ~/results.txt &
19090
fg 1
bash: fg: задача закончилась
+ Выход из 1 find / -name .ini 2> ~/results.txt
Запуск и обработка фоновых процессов: управление заданиями
Вы, наверное, заметили, что, после того, как вы ввели команду в Terminal "е, вам обычно нужно дождаться завершения ее работы, прежде чем shell вернет вам управление. Это значит, что вы запустили команду в приоритетном режиме . Однако, бывают случаи, когда это нежелательно.
Допустим, например, что вы решили рекурсивно скопировать один большой каталог в другой. Вы также решили игнорировать ошибки, поэтому вы перенаправили канал ошибок в /dev/null :
| cp -R images/ /shared/ 2>/dev/null |
Выполнение такой команды может занять несколько минут пока она не выполнится полностью. У вас есть два варианта решения: первый - жестокий, подразумевающий остановку (убивание) команды, а затем повторное ее выполнение, но уже в более подходящее время. Для этого нажмите Ctrl+c : при этом процесс будет завершен, а вы вернетесь назад к строке приглашения. Но подождите, пока что не делайте этого! Читайте дальше.
Допустим, вы хотите, чтобы команда выполнялась, а вы занимались чем-нибудь другим. Решением будет запуск процесса в фоновом режиме . Для этого нажмите Ctrl+z , чтобы приостановить процесс:
При этом процесс продолжит свою работу, но уже как фоновая задача, как это отмечено знаком & (амперсанд) в конце строки. Затем вы вернетесь назад в строку приглашения и сможете продолжить работу. Процесс, который выполняется как фоновая задача, или в фоновом режиме, называется фоновым заданием .
Конечно, вы можете сразу запускать процессы как фоновые задачи, добавляя знак & в конце команды. Например, вы можете запустить команду копирования каталога в фоновом режиме, набрав:
| cp -R images/ /shared/ 2>/dev/null & |
Если хотите, вы также можете восстановить этот процесс в приоритетный режим и дождаться его завершения, набрав fg (ForeGround - приоритетный). Чтобы перевести его назад в фоновый режим, введите следующую последовательность Ctrl+z , bg .
Таким способом
вы можете запустить несколько заданий: каждой команде при этом будет
присвоен номер задания. Команда
shell
"а
jobs
выводит список всех заданий, связанных с текущим
shell
"ом.
Перед заданием ставится знак
+
,
отмечающий последний процесс, запущенный в фоновом режиме. Для
восстановления конкретного задания в приоритетный режим вы можете
ввести команду
fg
- Вам нужно выполнить sql-запрос, результат которого нужно ждать несколько часов или дней?
- Вам нужно запустить приложение в фоне?
- Вам нужно выполнять программу в фоне и иметь возможность к ней вернуться?
- Вы используете линукс-консоль и работаете с ssh?
Тогда вам в обязательном порядке нужно знать о screen .
Основы screen
Screen в linux — это как "окна в Windows", которые можно свернуть/развернуть. Вы можете что то делать в одном окне, например смотреть фотографии. Но, если вам нужно кроме просмотра фотографий слушать музыку, то вы откроете новое окно (проводник), зайдёте в каталог с музыкой и отроете песню в аудио-программе.
Когда речь идёт о консоли линукс (особенно при работе по ssh ), то нам будет крайне не удобно в одной консоли выполнять различные приложения. А, может, и совсем не удастся выполнять вторую операцию в то время, когда первая ещё продолжает свою работу. Это первый момент. Второй момент заключается в том, что в случае какого-либо сбоя с вашей стороны (со стороны клиента) - текущая операция прервётся. Пара примеров, когда при работе с ssh может понадобиться screen :
- если вы копируете или перемещаете большой объём файлов с одного каталога в другой
- если вы выполняете тяжёлый sql-запрос
- если нужно запустить приложение, которое "захватывает" консоль
Наверное, вам было бы очень грустно, когда из-за случайно-закрытого терминала или скачка напряжения прервался бы sql-запрос, который уже выполнялся более 10 часов. В случае же с screen, 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 ставит процессы в очередь на выполнения.
Существует несколько основных команд для управлением процессами
- ps - выводить список запущенных процессов
- kill - отправляет сигнал на один или несколько процессов (в основном, чтобы "убить" их)
- jobs - альтернативный путь для просмотра процессов запущенных Вами
- bg - ставит выполнение процесса в фоновый режим
- fg - выводит выполнение процесса из фонового режима
Хотя может показаться, что эти знания достаточно абстрактны, но они могут найти свое практическое применение даже для среднего пользователя, который использует графический интерфейс. Возможно Вы еще не знаете, что большинство графических программ (если не все) можно запустить при помощи командной строки. Для примера попробуем запустить браузер, думаю у большинства 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 умеет отсылать несколько типов сигналов, чтобы узнать какие, введите kill -l . Ниже приведен список самых часто используемых сигналов (число в скобках - номер сигнала)
- SIGNUP(1) - изначально был предназначен для того, чтобы информировать программу о потере связи с управляющим терминалом (терминалы часто подключались к системе с помощью модемов, так что название сигнала происходит от hung up – повесить трубку). Сигнал SIGHUP посылается приложению так же и в том случае, если процесс-лидер сессии завершил свою работу. Многие программы-демоны , у которых нет лидера сессии, так же обрабатывают этот сигнал. В ответ на получение SIGHUP демон обычно перезапускается (или просто повторно читает файл конфигурации). По умолчанию программа, получившая этот сигнал, завершается.
- SIGINT(2) - обычно посылается процессу, если пользователь терминала дал команду прервать процесс (обычно эта команда - сочетание клавиш Ctrl + C)
- SIGTERM(15) - вызывает "вежливое" завершение программы. Получив этот сигнал, программа может выполнить необходимые перед завершением операции (например, сохранить открытые документы). Получение SIGTERM свидетельствует не об ошибке в программе, а о желании ОС или пользователя завершить ее.
- SIGKILL(9) - вызывает принудительное завершение работы программы. Программа не может ни обработать, ни игнорировать этот сигнал.
По умолчанию команда 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
В прошлый раз мы говорили о работе с потоками ввода, вывода и ошибок в bash-скриптах, о дескрипторах файлов и о перенаправлении потоков. Сейчас вы знаете уже достаточно много для того, чтобы писать что-то своё. На данном этапе освоения bash у вас вполне могут возникнуть вопросы о том, как управлять работающими скриптами, как автоматизировать их запуск.
До сих пор мы вводили имена скриптов в командную строку и нажимали Enter, что приводило к немедленному запуску программ, но это - не единственный способ вызова сценариев. Сегодня мы поговорим о том как скрипт может работать с сигналами Linux, о различных подходах к запуску скриптов и к управлению ими во время работы.
Сигналы Linux
В Linux существует более трёх десятков сигналов, которые генерирует система или приложения. Вот список наиболее часто используемых, которые наверняка пригодятся при разработке сценариев командной строки.| Код сигнала
|
Название
|
Описание
|
| 1 |
SIGHUP |
Закрытие терминала |
| 2 |
SIGINT |
Сигнал остановки процесса пользователем с терминала (CTRL + C) |
| 3 |
SIGQUIT |
Сигнал остановки процесса пользователем с терминала (CTRL + \) с дампом памяти |
| 9 |
SIGKILL |
Безусловное завершение процесса |
| 15 |
SIGTERM |
Сигнал запроса завершения процесса |
| 17 |
SIGSTOP |
Принудительная приостановка выполнения процесса, но не завершение его работы |
| 18 |
SIGTSTP |
Приостановка процесса с терминала (CTRL + Z), но не завершение работы |
| 19 |
SIGCONT |
Продолжение выполнения ранее остановленного процесса |
Если оболочка bash получает сигнал SIGHUP когда вы закрываете терминал, она завершает работу. Перед выходом она отправляет сигнал SIGHUP всем запущенным в ней процессам, включая выполняющиеся скрипты.
Сигнал SIGINT приводит к временной остановке работы. Ядро Linux перестаёт выделять оболочке процессорное время. Когда это происходит, оболочка уведомляет процессы, отправляя им сигнал SIGINT .
Bash-скрипты не контролируют эти сигналы, но они могут распознавать их и выполнять некие команды для подготовки скрипта к последствиям, вызываемым сигналами.
Отправка сигналов скриптам
Оболочка bash позволяет вам отправлять скриптам сигналы, пользуясь комбинациями клавиш на клавиатуре. Это оказывается очень кстати если нужно временно остановить выполняющийся скрипт или завершить его работу.Завершение работы процесса
Комбинация клавиш CTRL + C генерирует сигнал SIGINT и отправляет его всем процессам, выполняющимся в оболочке, что приводит к завершению их работы.Выполним в оболочке такую команду:
$ sleep 100
После этого завершим её работу комбинацией клавиш CTRL + C .
Завершение работы процесса с клавиатуры
Временная остановка процесса
Комбинация клавиш CTRL + Z позволяет сгенерировать сигнал SIGTSTP , который приостанавливает работу процесса, но не завершает его выполнение. Такой процесс остаётся в памяти, его работу можно возобновить. Выполним в оболочке команду: $ sleep 100
И временно остановим её комбинацией клавиш CTRL + Z .
Приостановка процесса
Число в квадратных скобках - это номер задания, который оболочка назначает процессу. Оболочка рассматривает процессы, выполняющиеся в ней, как задания с уникальными номерами. Первому процессу назначается номер 1, второму - 2, и так далее.
Если вы приостановите задание, привязанное к оболочке, и попытаетесь выйти из неё, bash выдаст предупреждение.
Просмотреть приостановленные задания можно такой командой:
Ps –l
Список заданий
В колонке S , выводящей состояние процесса, для приостановленных процессов выводится T . Это указывает на то, что команда либо приостановлена, либо находится в состоянии трассировки.
Если нужно завершить работу приостановленного процесса, можно воспользоваться командой kill . Подробности о ней можно почитать .
Выглядит её вызов так:
Kill processID
Перехват сигналов
Для того, чтобы включить в скрипте отслеживание сигналов Linux, используется команда trap . Если скрипт получает сигнал, указанный при вызове этой команды, он обрабатывает его самостоятельно, при этом оболочка такой сигнал обрабатывать не будет.Команда 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 .
Модификация перехваченных сигналов и отмена перехвата
Для модификации перехваченных скриптом сигналов можно выполнить команду 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 "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 сработала обычным образом, завершив работу скрипта.
Выполнение сценариев командной строки в фоновом режиме
Иногда bash-скриптам требуется немало времени для выполнения некоей задачи. При этом вам может понадобиться возможность нормально работать в командной строке, не дожидаясь завершения скрипта. Реализовать это не так уж и сложно.Если вы видели список процессов, выводимый командой ps , вы могли заметить процессы, которые выполняются в фоне и не привязаны к терминалу.
Напишем такой скрипт:
#!/bin/bash
count=1
while [ $count -le 10 ]
do
sleep 1
count=$(($count + 1))
done
Запустим его, указав после имени символ амперсанда (&):
$ ./myscipt &
Это приведёт к тому, что он будет запущен как фоновый процесс.
Запуск скрипта в фоновом режиме
Скрипт будет запущен в фоновом процессе, в терминал выведется его идентификатор, а когда его выполнение завершится, вы увидите сообщение об этом.
Обратите внимание на то, что хотя скрипт выполняется в фоне, он продолжает использовать терминал для вывода сообщений в STDOUT и STDERR , то есть, выводимый им текст или сообщения об ошибках можно будет увидеть в терминале.
Список процессов
При таком подходе, если выйти из терминала, скрипт, выполняющийся в фоне, так же завершит работу.
Что если нужно, чтобы скрипт продолжал работать и после закрытия терминала?
Выполнение скриптов, не завершающих работу при закрытии терминала
Скрипты можно выполнять в фоновых процессах даже после выхода из терминальной сессии. Для этого можно воспользоваться командой nohup . Эта команда позволяет запустить программу, блокируя сигналы SIGHUP , отправляемые процессу. В результате процесс будет исполняться даже при выходе из терминала, в котором он был запущен.Применим эту методику при запуске нашего скрипта:
Nohup ./myscript &
Вот что будет выведено в терминал.
Команда nohup
Команда nohup отвязывает процесс от терминала. Это означает, что процесс потеряет ссылки на STDOUT и STDERR . Для того, чтобы не потерять данные, выводимые скриптом, nohup автоматически перенаправляет сообщения, поступающие в STDOUT и в STDERR , в файл nohup.out .
Обратите внимание на то, что при запуске нескольких скриптов из одной и той же директории то, что они выводят, попадёт в один файл nohup.out .
Просмотр заданий
Команда jobs позволяет просматривать текущие задания, которые выполняются в оболочке. Напишем такой скрипт: #!/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 процессов.
Перезапуск приостановленных заданий
Для того, чтобы перезапустить скрипт в фоновом режиме, можно воспользоваться командой bg .Запустим скрипт:
$ ./myscript
Нажмём CTRL + Z , что временно остановит его выполнение. Выполним следующую команду:
$ bg
Команда bg
Теперь скрипт выполняется в фоновом режиме.
Если у вас имеется несколько приостановленных заданий, для перезапуска конкретного задания команде bg можно передать его номер.
Для перезапуска задания в обычном режиме воспользуйтесь командой fg:
Планирование запуска скриптов
Linux предоставляет пару способов запуска bash-скриптов в заданное время. Это команда at и планировщик заданий cron .Вызов команды at выглядит так:
At [-f filename] time
Эта команда распознаёт множество форматов указания времени.
- Стандартный, с указанием часов и минут, например - 10:15.
- С использованием индикаторов AM/PM, до или после полудня, например - 10:15PM.
- С использованием специальных имён, таких, как now , noon , midnight .
- Стандартный формат указания даты, при котором дата записывается по шаблонам MMDDYY , MM/DD/YY , или DD.MM.YY .
- Текстовое представление даты, например, Jul 4 или Dec 25 , при этом год можно указать, а можно обойтись и без него.
- Запись вида now + 25 minutes .
- Запись вида 10:15PM tomorrow .
- Запись вида 10:15 + 7 days .
$ at -f ./myscript now
Планирование заданий с использованием команды at
Ключ -M при вызове at используется для отправки того, что выведет скрипт, по электронной почте, если система соответствующим образом настроена. Если отправка электронного письма невозможна, этот ключ просто подавит вывод.
Для того чтобы посмотреть список заданий, ожидающих выполнения, можно воспользоваться командой atq:
Список заданий, ожидающих выполнения
Удаление заданий, ожидающих выполнения
Удалить задание, ожидающее выполнения, позволяет команда atrm . При её вызове указывают номер задания: $ atrm 18
Удаление задания
Запуск скриптов по расписанию
Планирование однократного запуска скриптов с использованием команды at способно облегчить жизнь во многих ситуациях. Но как быть, если нужно, чтобы скрипт выполнялся в одно и то же время ежедневно, или раз в неделю, или раз в месяц?В 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 .
Итоги
Сегодня мы разобрали вопросы, касающиеся управления жизненным циклом сценариев, поговорили о том, как запускать скрипты в фоне, как планировать их выполнение по расписанию. В следующий раз читайте о функциях в bash-скриптах и о разработке библиотек.Уважаемые читатели! А вы пользуетесь средствами планирования запуска сценариев командной строки по расписанию? Если да - расскажите пожалуйста о них.
Селфи палки — что это и какие они бывают Лучшие приложения для селфи
Получение Root LG L70 (D325)
Как найти ролик на ютубе, если не знаешь названия
Почему упал ФПС в World of Tanks
Читы на слитки в скайриме - как получить слитки в игре