Фоновый запуск процессов в Linux

Введение

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

Понимание фоновых процессов

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

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

Перейдите в каталог проекта:

cd ~/project

Создайте файл с именем long-task.sh с помощью редактора nano:

nano long-task.sh

Добавьте следующее содержимое в файл:

#!/bin/bash
## This script simulates a long-running task
echo "Starting long task..."
for i in {1..20}; do
  echo "Processing step $i..."
  sleep 5
done
echo "Long task completed."

Нажмите Ctrl+O, затем Enter, чтобы сохранить файл, и Ctrl+X, чтобы выйти из nano.

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

chmod +x long-task.sh

Теперь запустите скрипт на переднем плане:

./long-task.sh

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

Нажмите Ctrl+C, чтобы прервать выполнение скрипта до его завершения.

Запуск процессов в фоновом режиме

Чтобы запустить процесс в фоновом режиме, просто добавьте амперсанд (&) в конце команды. Это указывает оболочке (shell) выполнить команду в фоновом режиме.

Давайте запустим наш скрипт long-task.sh в фоновом режиме:

cd ~/project
./long-task.sh &

Вы должны увидеть вывод, похожий на следующий:

[1] 1234
Starting long task...
Processing step 1...

Здесь [1] — это номер задания (job number), присвоенный оболочкой, а 1234 — идентификатор процесса (PID). Номер задания используется для обращения к этому фоновому процессу внутри оболочки, в то время как PID используется операционной системой для идентификации процесса.

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

Например, попробуйте создать другой файл:

echo "I can do other work while the script runs" > background-demo.txt
cat background-demo.txt

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

Важное примечание: Вполне нормально видеть вывод фонового процесса, появляющийся в вашем терминале. Когда вы запускаете процесс в фоновом режиме с помощью &, процесс выполняется в фоновом режиме, но его потоки вывода (stdout и stderr) по-прежнему подключены к вашему терминалу. Это означает:

Процесс выполняется в фоновом режиме (вы можете вводить другие команды)
Процесс продолжает выполняться, не блокируя ваш терминал
Вывод по-прежнему отображается на вашем экране (что может смешиваться с другими вашими командами)

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

Проверка фоновых процессов

Linux предоставляет несколько команд для проверки того, какие процессы выполняются в фоновом режиме. Две наиболее распространенные из них — jobs и ps.

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

Команда jobs показывает статус всех фоновых заданий (jobs) в текущей сессии оболочки:

jobs

Вы должны увидеть вывод, похожий на следующий:

[1]+  Running    ./long-task.sh &

Знак + указывает, что это текущее задание по умолчанию, что означает, что оно будет выбрано, если вы используете команды, такие как fg или bg, без указания номера задания.

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

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

ps aux | grep long-task.sh

Вывод должен включать строку для вашего фонового скрипта:

labex     1234  0.0  0.0   4508  1996 pts/0    S    12:34   0:00 /bin/bash ./long-task.sh

Давайте создадим еще один фоновый процесс, чтобы мы могли видеть несколько заданий:

cd ~/project
nano another-task.sh

Добавьте следующее содержимое:

#!/bin/bash
## This script simulates another task
echo "Starting another task..."
for i in {1..20}; do
  echo "Another task - step $i..."
  sleep 5
done
echo "Another task completed."

Сохраните и выйдите из nano (Ctrl+O, Enter, Ctrl+X), затем сделайте скрипт исполняемым:

chmod +x another-task.sh

Запустите этот скрипт также в фоновом режиме:

./another-task.sh &

Теперь снова проверьте ваши фоновые задания:

jobs

Вы должны увидеть оба задания в списке:

[1]-  Running    ./long-task.sh &
[2]+  Running    ./another-task.sh &

Управление фоновыми процессами

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

Перевод фонового процесса на передний план

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

Давайте переведем наше первое задание на передний план:

fg %1

%1 относится к заданию номер 1. Вы увидите вывод скрипта long-task.sh в вашем терминале, и приглашение командной строки будет недоступно до тех пор, пока процесс не завершится или вы его не остановите.

Чтобы прервать процесс и вернуться к командной строке, нажмите Ctrl+C.

Перевод процесса с переднего плана в фоновый режим

Вы также можете перевести процесс с переднего плана в фоновый режим. Сначала приостановите процесс на переднем плане с помощью Ctrl+Z, а затем используйте команду bg для его продолжения в фоновом режиме.

Запустите новый процесс на переднем плане:

cd ~/project
./long-task.sh

Через несколько секунд нажмите Ctrl+Z, чтобы приостановить процесс. Вы увидите сообщение, похожее на:

[1]+  Stopped    ./long-task.sh

Теперь продолжите его выполнение в фоновом режиме:

bg

Процесс возобновит выполнение в фоновом режиме, и вы увидите:

[1]+ ./long-task.sh &

Вы можете проверить, что он выполняется, с помощью:

jobs

Завершение фоновых процессов

Чтобы завершить фоновый процесс, вы можете использовать команду kill с номером задания или идентификатором процесса (PID):

kill %1

Или используя PID (замените 1234 на фактический PID из вывода команды ps):

kill 1234

Чтобы убедиться, что процесс был завершен:

jobs

Вы можете увидеть сообщение, указывающее, что задание было завершено:

[1]+  Terminated    ./long-task.sh

Запуск процессов после выхода из системы

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

Давайте создадим скрипт, который будет работать долго:

cd ~/project
nano persistent-task.sh

Добавьте следующее содержимое:

#!/bin/bash
## This script runs for a very long time
echo "Starting persistent task at $(date)" > persistent-output.log
for i in {1..100}; do
  echo "Iteration $i at $(date)" >> persistent-output.log
  sleep 10
done
echo "Persistent task completed at $(date)" >> persistent-output.log

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

chmod +x persistent-task.sh

Теперь запустите его с помощью nohup и переведите в фоновый режим:

nohup ./persistent-task.sh &

Вы увидите вывод, похожий на следующий:

[1] 5678
nohup: ignoring input and appending output to 'nohup.out'

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

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

## Перенаправить вывод в конкретный файл
./long-task.sh > task-output.log 2>&1 &

## Или перенаправить в /dev/null, чтобы полностью отбросить вывод
./long-task.sh > /dev/null 2>&1 &

2>&1 перенаправляет как стандартный вывод, так и вывод ошибок. Таким образом, фоновый процесс выполняется бесшумно, не загромождая ваш терминал.

Вы можете проверить, выполняется ли процесс:

ps aux | grep persistent-task.sh

И вы можете просмотреть файл вывода:

cat persistent-output.log

Вывод показывает время начала и итерации постоянной задачи.

Команда disown

Другой способ поддерживать запущенные процессы после выхода из системы — использовать команду disown. Сначала запустите процесс в фоновом режиме:

cd ~/project
./persistent-task.sh &

Затем используйте disown, чтобы отсоединить его от терминала:

disown %1

Теперь этот процесс будет продолжать работать, даже если вы закроете терминал.

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

Резюме

В этой лабораторной работе вы освоили основные навыки Linux для управления фоновыми процессами. Вы практиковались в следующем:

Создание и выполнение скриптов как в режиме переднего плана, так и в фоновом режиме
Запуск процессов в фоновом режиме с использованием оператора &
Проверка состояния фоновых процессов с помощью jobs и ps
Управление процессами с помощью команд fg и bg для их перемещения между передним планом и фоном
Завершение фоновых процессов с помощью команды kill
Запуск процессов, которые продолжают работать после выхода из системы, с помощью nohup и disown

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