Как приостановить процесс в linux
Всякая выполняющаяся в Linux программа называется процессом. Linux как многозадачная система характеризуется тем, что одновременно может выполняться множество процессов, принадлежащих одному или нескольким пользователям. Вывести список исполняющихся в текущее время процессов можно командой ps , например, следующим образом:
Обратите внимание, что по умолчанию команда 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 [1] . Восстановить прерванное задание никаким образом невозможно. Следует также знать, что некоторые программы перехватывают сигнал TERM (при помощи обработчика), так что нажатие комбинации клавиш Ctrl — C (о) может не прервать процесс немедленно. Это сделано для того, чтобы программа могла уничтожить следы своей работы прежде, чем она будет завершена. На практике, некоторые программы вообще нельзя прервать таким способом.
Перевод в фоновый режим и уничтожение заданий
Начнём с простого примера. Рассмотрим команду yes, которая на первый взгляд может показаться бесполезной. Эта команда посылает бесконечный поток строк, состоящих из символа y на стандартный вывод. Посмотрим, как работает эта команда:
Последовательность таких строк будет бесконечно продолжаться. Уничтожить этот процесс можно, отправив ему сигнал прерывания, т. е. нажав Ctrl — C . Поступим теперь иначе. Чтобы на экран не выводилась эта бесконечная последовательность перенаправим стандартный вывод команды yes на /dev/null . Как вы, возможно, знаете, устройство /dev/null действует как « чёрная дыра »: все данные, посланные в это устройство, пропадают. С помощью этого устройства очень удобно избавляться от слишком обильного вывода некоторых программ.
Теперь на экран ничего не выводится. Однако и приглашение командной оболочки также не возвращается. Это происходит потому, что команда yes все ещё работает и посылает свои сообщения, состоящие из букв y на /dev/null . Уничтожить это задание также можно, отправив ему сигнал прерывания.
Допустим теперь, что вы хотите, чтобы команда yes продолжала работать, но при этом и приглашение командной оболочки должно вернуться на экран, так чтобы вы могли работать с другими программами. Для этого можно команду yes перевести в фоновый режим, и она будет там работать, не общаясь с вами.
Один способ перевести процесс в фоновый режим — приписать символ & к концу команды. Пример:
Сообщение [1] представляет собой номер задания (job number) для процесса yes. Командная оболочка присваивает номер задания каждому исполняемому заданию. Поскольку yes является единственным исполняемым заданием, ему присваивается номер 1. Число 164 является идентификационным номером, соответствующим данному процессу ( PID ), и этот номер также дан процессу системой. Как мы увидим дальше, к процессу можно обращаться, указывая оба этих номера.
Итак, теперь у нас есть процесс команды yes, работающий в фоне, и непрерывно посылающий поток из букв y на устройство /dev/null . Для того, чтобы узнать статус этого процесса, нужно исполнить команду jobs , которая является внутренней командой оболочки.
Мы видим, что эта программа действительно работает. Для того, чтобы узнать статус задания, можно также воспользоваться командой ps , как это было показано выше.
Для того, чтобы передать процессу сигнал (чаще всего возникает потребность прервать работу задания) используется утилита kill . В качестве аргумента этой команде даётся либо номер задания, либо PID . Необязательный параметр — номер сигнала, который нужно отправить процессу. По умолчанию отправляется сигнал TERM . В рассмотренном выше случае номер задания был 1, так что команда kill %1 прервёт работу задания. Когда к заданию обращаются по его номеру (а не PID ), тогда перед этим номером в командной строке нужно поставить символ процента (« % »).
Теперь введём команду jobs снова, чтобы проверить результат предыдущего действия:
Фактически задание уничтожено, и при вводе команды jobs следующий раз на экране о нем не будет никакой информации.
Уничтожить задание можно также, используя идентификационный номер процесса ( PID ). Этот номер, наряду с идентификационным номером задания, указывается во время старта задания. В нашем примере значение PID было 164, так что команда kill 164 была бы эквивалентна команде kill %1 . При использовании PID в качестве аргумента команды kill вводить символ « % » не требуется.
Приостановка и продолжение работы заданий
Запустим сначала процесс командой yes на переднем плане, как это делалось раньше:
Как и ранее, поскольку процесс работает на переднем плане, приглашение командной оболочки на экран не возвращается.
Теперь вместо того, чтобы прервать задание комбинацией клавиш Ctrl — C , задание можно приостановить (suspend, буквально — подвесить ), отправив ему сигнал STOP . Для приостановки задания надо нажать соответствующую комбинацию клавиш, обычно это Ctrl — Z .
Приостановленный процесс попросту не выполняется. На него не тратятся вычислительные ресурсы процессора. Приостановленное задание можно запустить выполняться с той же точки, как будто бы оно и не было приостановлено.
Для возобновления выполнения задания на переднем плане можно использовать команду fg (от слова foreground — передний план).
Командная оболочка ещё раз выведет на экран название команды, так что пользователь будет знать, какое именно задание он в данный момент запустил на переднем плане. Приостановим это задание ещё раз нажатием клавиш Ctrl — Z , но в этот раз запустим его в фоновый режим командой bg (от слова background — фон). Это приведёт к тому, что данный процесс будет работать так, как если бы при его запуске использовалась команда с символом & в конце (как это делалось в предыдущем разделе):
При этом приглашение командной оболочки возвращается. Сейчас команда jobs должна показывать, что процесс yes действительно в данный момент работает; этот процесс можно уничтожить командой kill , как это делалось раньше.
Для того, чтобы приостановить задание, работающее в фоновом режиме, нельзя воспользоваться комбинацией клавиш Ctrl — Z . Прежде, чем приостанавливать задание, его нужно перевести на передний план командой fg и лишь потом приостановить. Таким образом, команду fg можно применять либо к приостановленным заданиям, либо к заданию, работающему в фоновом режиме.
Между заданиями в фоновом режиме и приостановленными заданиями есть большая разница. Приостановленное задание не работает — на него не тратятся вычислительные мощности процессора. Это задание не выполняет никаких действий. Приостановленное задание занимает некоторый объем оперативной памяти компьютера, через некоторое время ядро откачает эту часть памяти на жёсткий диск « до востребования ». Напротив, задание в фоновом режиме выполняется, использует память и совершает некоторые действия, которые, возможно, вам требуются, но вы в это время можете работать с другими программами.
Задания, работающие в фоновом режиме, могут пытаться выводить некоторый текст на экран. Это будет мешать работать над другими задачами.
Здесь стандартный вывод не был перенаправлен на устройство /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 являются внутренними командами оболочки. Если, по некоторой причине, вы используете командную оболочку, которая не поддерживает функции управления заданиями, то вы в ней этих (и подобных) команд не отыщете.
[1] Прерывающая комбинация клавиш может быть установлена с помощью команды stty .
click fraud protection
Вы можете приостановить процесс по разным причинам. Самый важный из них — это когда на обработку поступает большое количество интерактивных запросов. Система управления памятью выгружает процесс из памяти, освобождая место для других процессов.
В этой статье мы покажем, как убить или приостановить процесс в системе Linux.
Приостановить процесс в Linux
Приостановить процесс в Linux довольно просто. В UNIX, набрав «Ctrl+Z», вы можете приостановить задание, которое в данный момент подключено к вашему терминалу. Командная строка сообщит вам, что процесс остановлен. Приостановленному заданию будет присвоен идентификатор процесса.
Если вы хотите запустить этот процесс в фоновом режиме, введите команду «bg»:
Когда нет другого способа приостановить процесс, мы можем остановить его вручную с помощью терминала.
Чтобы приостановить или завершить процесс, сначала вы найдете PID (идентификатор процесса) с помощью команды «pd». Найдя идентификатор процесса, вы можете приостановить это задание с помощью команд kill, pkill, killall или top.
Пример
Например, мы хотим загрузить полный стабильный пакет Joomla с помощью команды wget с помощью терминала.
$ wget https: // Downloads.joomla.org / смс / джумла3 / 3 — 8 — 5 / Joomla_3- 8 — 5 -Stable-Full_Package.zip &
Это занимает много времени по сравнению с другими процессами. Чтобы проверить идентификатор процесса, используйте следующую команду:
Вы также можете найти идентификатор процесса для конкретного запущенного задания с помощью этой команды:
Если несколько файлов загружаются в фоновом режиме вашей системы, используйте эту команду:
$ PS вспомогательный | grep “ wget ”
Как только вы нашли идентификатор процесса, вы можете приостановить задание, используя идентификатор процесса, используя следующую команду «kill»:
$ убийство -ОСТАНАВЛИВАТЬСЯ ПИД
Например, мы хотим убить или приостановить задание с идентификатором процесса «5562». В этом случае используйте эту команду:
$ убийство -ОСТАНАВЛИВАТЬСЯ 5562
Если вы хотите запустить этот процесс снова, используйте эту команду:
$ убийство -ПРОДОЛЖЕНИЕ 5562
Просмотрите идентификатор запущенного процесса с помощью следующей команды:
Вывод
В этом посте мы обсуждали, как приостановить процесс в Linux двумя способами: сочетанием клавиш и через терминал. Однако, если вы перезагрузите систему, этот метод не сработает. При перезагрузке системы идентификаторы всех процессов автоматически изменятся.
Как использовать Bash Job Control для управления передним и фоновым процессами
В этом руководстве мы поговорим о том, как bash , система Linux и ваш терминал объединяются, чтобы обеспечить управление процессами и заданиями. Вprevious guide мы обсудили, как команды ps , kill и nice могут использоваться для управления процессами в вашей системе.
Эта статья будет сосредоточена на управлении передним и фоновым процессами и продемонстрирует, как использовать функции управления заданиями вашей оболочки для повышения гибкости при выполнении команд.
Управление процессами переднего плана
Большинство процессов, которые вы запускаете на компьютере с Linux, будут выполняться на переднем плане. Команда начнет выполнение, блокируя использование оболочки на время процесса. Процесс может разрешить взаимодействие с пользователем или может просто пройти через процедуру и затем завершиться. Любой вывод будет отображаться в окне терминала по умолчанию. Ниже мы обсудим основной способ управления приоритетными процессами.
Запуск процесса
По умолчанию процессы запускаются на переднем плане. Пока программа не выйдет или не изменит состояние, вы не сможете взаимодействовать с оболочкой.
Некоторые команды переднего плана завершаются очень быстро и почти сразу возвращают вас в приглашение оболочки. Например, эта команда:
Это выведет «Hello World» в терминал, а затем вернет вас в командную строку.
Другие команды переднего плана выполняются дольше, блокируя доступ к оболочке на время. Это может быть связано с тем, что команда выполняет более сложную операцию, или потому что она настроена на выполнение до тех пор, пока она не будет явно остановлена или пока она не получит другой пользовательский ввод.
Команда, которая выполняется бесконечно, — это утилита top . После запуска он продолжит работу и обновит свой дисплей, пока пользователь не завершит процесс:
Вы можете выйти, набрав «q». Некоторые процессы не имеют специальной функции выхода. Чтобы остановить это, вам придется использовать другой метод.
Завершение процесса
Предположим, мы запускаем простой цикл bash в командной строке. Мы можем запустить цикл, который будет печатать «Hello World» каждые десять секунд. Этот цикл будет продолжаться вечно, пока не будет явно завершен:
Циклы не имеют клавиши «выход». Нам придется остановить процесс, отправив емуsignal. В Linux ядро может отправлять сигналы процессов, чтобы запросить их выход или изменение состояний. Терминалы Linux обычно настроены на отправку сигнала «SIGINT» (обычно сигнал номер 2) текущему процессу переднего плана при нажатии комбинации клавиш CTRL-C . Сигнал SIGINT сообщает программе, что пользователь запросил завершение с помощью клавиатуры.
Чтобы остановить начатый цикл, удерживайте клавишу управления и нажмите клавишу «c»:
Цикл выйдет, вернув управление оболочке.
Сигнал SIGINT, отправляемый комбинацией CTRL-C , является одним из многих сигналов, которые могут быть отправлены программам. Большинство сигналов не имеют связанных с ними клавиатурных комбинаций и должны отправляться с помощью команды kill (мы рассмотрим это позже).
Приостановка процессов
Мы упоминали выше, что приоритетный процесс будет блокировать доступ к оболочке на время их выполнения. Что если мы запустим процесс на переднем плане, но затем поймем, что нам нужен доступ к терминалу?
Другим сигналом, который мы можем отправить, является сигнал «SIGTSTP» (обычно сигнал номер 20). Когда мы нажимаем CTRL-Z , наш терминал регистрирует команду «приостановить», которая затем отправляет сигнал SIGTSTP процессу переднего плана. Это в основном приостановит выполнение команды и вернет управление в терминал.
В качестве демонстрации давайте будем использовать ping для подключения к google.com каждые 5 секунд. Перед командой ping мы будем указывать command , что позволит нам обойти любые псевдонимы оболочки, которые искусственно устанавливают максимальное количество для команды:
Вместо того, чтобы завершать команду с помощью CTRL-C , введите CTRL-Z :
Вы увидите вывод, который выглядит следующим образом:
Команда ping временно остановлена, и вы снова получите доступ к приглашению оболочки. Мы можем использовать инструмент процесса ps , чтобы показать это:
Мы видим, что процесс ping все еще указан, но в столбце «STAT» есть буква «T». Страница руководства ps сообщает нам, что это задание, которое было «остановлено (a) сигналом управления заданием».
Мы обсудим более подробно, как изменить состояния процесса, но сейчас мы можем возобновить выполнение команды на переднем плане, набрав:
Как только процесс возобновится, остановите его с помощью CTRL-C :
Управление фоновыми процессами
Основной альтернативой запуску процесса на переднем плане является разрешение его выполнения в фоновом режиме. Фоновый процесс связан с конкретным терминалом, который его запустил, но не блокирует доступ к оболочке. Вместо этого он выполняется в фоновом режиме, предоставляя пользователю возможность взаимодействовать с системой во время выполнения команды.
Из-за того, как процессы переднего плана взаимодействуют с его терминалом, для каждого окна терминала может быть только один процесс переднего плана. Поскольку фоновые процессы немедленно возвращают управление оболочке, не дожидаясь завершения процесса, многие фоновые процессы могут выполняться одновременно.
Стартовые процессы
Вы можете запустить фоновый процесс, добавив символ амперсанда («&») в конец ваших команд. Это говорит оболочке не ждать завершения процесса, а начинать выполнение и немедленно возвращать пользователя к приглашению. Вывод команды будет по-прежнему отображаться в терминале (кромеredirected), но вы можете вводить дополнительные команды по мере продолжения фонового процесса.
Например, мы можем запустить тот же процесс проверки связи из последнего раздела в фоновом режиме, набрав:
Вы увидите вывод системы управления заданиями bash , который выглядит следующим образом:
Вы также увидите нормальный вывод команды ping :
Однако вы также можете вводить команды одновременно. Вывод фонового процесса будет смешан между вводом и выводом ваших процессов переднего плана, но он не будет мешать выполнению процессов переднего плана.
Листинг фоновых процессов
Чтобы увидеть все остановленные или фоновые процессы, вы можете использовать команду jobs :
Если у вас запущена команда ping в фоновом режиме, вы увидите примерно следующее:
Это показывает, что в настоящее время у нас запущен один фоновый процесс. [1] представляет собой «спецификацию задания» или номер задания. Мы можем ссылаться на это с другими командами управления заданиями и процессами, такими как kill , fg и bg , поставив перед номером задания знак процента. В этом случае мы будем ссылаться на это задание как на %1 .
Остановка фоновых процессов
Мы можем остановить текущий фоновый процесс несколькими способами. Самый простой способ — использовать команду kill с соответствующим номером задания. Например, мы можем убить наш запущенный фоновый процесс, набрав:
В зависимости от того, как настроен ваш терминал, сразу или в следующий раз, когда вы нажмете ENTER, вы увидите статус завершения задания:
Если мы снова проверим команду jobs , мы не увидим текущих заданий.
Изменение состояний процесса
Теперь, когда мы знаем, как запускать и останавливать процессы в фоновом режиме, мы можем поговорить о том, как изменить их состояние.
Мы продемонстрировали одно изменение состояния ранее, когда описывали, как остановить или приостановить процесс с помощью CTRL-Z . Когда процессы находятся в этом остановленном состоянии, мы можем переместить процесс переднего плана в фоновый режим или наоборот.
Перемещение процессов переднего плана на задний план
Если мы забудем завершить команду с помощью & при ее запуске, мы все равно можем переместить процесс в фоновый режим.
Первый шаг — снова остановить процесс с помощью CTRL-Z :
После остановки процесса мы можем использовать команду bg , чтобы снова запустить его в фоновом режиме:
Вы снова увидите строку состояния задания, на этот раз с добавленным амперсандом:
По умолчанию команда bg работает с последним остановленным процессом. Если вы остановили несколько процессов подряд, не запустив их снова, вы можете сослаться на процесс по номеру задания, чтобы установить правильный процесс.
Обратите внимание, что не все команды могут быть фоновыми. Некоторые процессы будут автоматически завершены, если обнаружат, что они были запущены со стандартным входом и выходом, напрямую подключенным к активному терминалу.
Перемещение фоновых процессов на передний план
Мы также можем переместить фоновые процессы на передний план, набрав fg :
Это работает с вашим последним фоновым процессом (обозначенным знаком «» в выводе «+ jobs»). Это немедленно приостанавливает процесс и выводит его на первый план. Чтобы указать другое задание, используйте его номер задания:
Когда задание находится на переднем плане, вы можете убить его с помощью CTRL-C , дать ему завершиться или приостановить и снова запустить его в фоновом режиме.
Работа с SIGHUP
Находится ли процесс в фоновом режиме или на переднем плане, он довольно тесно связан с экземпляром терминала, который его запустил. Когда терминал закрывается, он обычно отправляет сигнал SIGHUP всем процессам (передний план, фон или остановлен), которые связаны с терминалом. Это сигнализирует о прекращении процессов, потому что их управляющий терминал вскоре будет недоступен. Что, если вы хотите закрыть терминал, но фоновые процессы работают?
Есть несколько способов сделать это. Наиболее гибкими способами обычно являются использование терминального мультиплексора, такого как screen или tmux , или использование служебной программы, которая предоставляет, по крайней мере, их функцию отсоединения, например dtach .
Тем не менее, это не всегда вариант. Иногда эти программы недоступны, или вы уже запустили процесс, который вам нужен для продолжения работы. Иногда это излишне для того, что вам нужно сделать.
Используя nohup
Если при запуске процесса вы знаете, что хотите закрыть терминал до завершения процесса, вы можете запустить его с помощью команды nohup . Это делает запущенный процесс невосприимчивым к сигналу SIGHUP. Он продолжит работать, когда терминал закроется. Он будет переназначен как дочерний элемент системы init:
Вы увидите строку, которая выглядит следующим образом, указывая, что вывод команды будет записан в файл с именем nohup.out (в текущем каталоге, если он доступен для записи, иначе в ваш домашний каталог):
Это делается для того, чтобы вывод не терялся, если окно терминала закрыто.
Если вы закроете окно терминала и откроете еще одно, процесс все равно будет запущен. Вы не увидите его в выводе команды jobs , потому что каждый экземпляр терминала поддерживает свою собственную независимую очередь заданий. Закрытие терминала привело к уничтожению ping job, хотя ping process все еще работает.
Чтобы убить процесс ping , вам нужно найти его идентификатор процесса (или «PID»). Вы можете сделать это с помощью команды pgrep (есть также команда pkill , но этот двухкомпонентный метод гарантирует, что мы убиваем только предполагаемый процесс). Используйте pgrep и флаг -a для поиска исполняемого файла:
Затем вы можете завершить процесс, ссылаясь на возвращенный PID, который является номером в первом столбце:
Вы можете удалить файл nohup.out , если он вам больше не нужен.
Использование отречься
Команда nohup полезна, но только в том случае, если вы знаете, что она вам понадобится в момент запуска процесса. Система управления заданиями bash предоставляет другие методы достижения аналогичных результатов с помощью встроенной команды disown .
Команда disown в своей конфигурации по умолчанию удаляет задание из очереди заданий терминала. Это означает, что им больше нельзя управлять с помощью механизмов управления заданиями, обсуждаемых в этом руководстве (например, fg , bg , CTRL-Z , CTRL-C ). Он будет немедленно удален из списка в выводе jobs и больше не будет связан с терминалом.
Команда вызывается указанием номера задания. Например, чтобы немедленно отказаться от задания 2, мы могли бы набрать:
Это оставляет процесс в состоянии, похожем на состояние процесса nohup после закрытия управляющего терминала. Исключением является то, что любой вывод будет потерян, когда управляющий терминал закроется, если он не будет перенаправлен в файл.
Обычно вы не хотите полностью удалять процесс из-под контроля задания, если не закрываете окно терминала сразу. Вместо этого вы можете передать флаг -h процессу disown , чтобы пометить процесс игнорировать сигналы SIGHUP, но в противном случае продолжить работу как обычное задание:
В этом состоянии вы можете использовать обычные механизмы управления заданиями, чтобы продолжать контролировать процесс до закрытия терминала. После закрытия терминала вы опять застрянете с процессом, который некуда выводить, если вы не перенаправили файл при запуске.
Чтобы обойти это, вы можете попытаться перенаправить вывод вашего процесса после того, как он уже запущен. Это выходит за рамки данного руководства, но вы можете взглянуть наthis post, чтобы понять, как это сделать.
Использование опции оболочки huponexit
В Bash также есть другой способ избежать проблемы SIGHUP для дочерних процессов. Параметр оболочки huponexit определяет, будет ли bash отправлять своим дочерним процессам сигнал SIGHUP при выходе.
Параметр huponexit влияет на поведение SIGHUP только тогда, когда инициируется завершение сеанса оболочкиfrom within the shell itself. Некоторые примеры того, когда это применимо, — это когда в сеансе выполняется команда exit или CTRL-D .
Когда сеанс оболочки завершается через саму программу терминала (путем закрытия окна и т. Д.), Команда huponexit будет иметь эффектno. Вместо того, чтобы bash решал, следует ли отправлять сигнал SIGHUP, терминал сам отправит сигнал SIGHUP на bash , который затем (правильно) распространит сигнал на свои дочерние процессы.
Несмотря на приведенные выше предостережения, вариант huponexit , пожалуй, один из самых простых. Вы можете увидеть, включена эта функция или нет, набрав:
7 способов убить не отвечающие программы в Linux
Программное обеспечение в Linux достаточно надежно, чтобы работать без проблем, но иногда, даже самые лучшие приложения могут зависнуть. Вместо того, чтобы ждать их сбоя, вы можете убить эти не отвечающие программы. На самом деле, существует так много способов убить программы для Linux, что вы можете оказаться избалованными выбором!
Если у вас возникают проблемы с приложением в Linux, вот несколько способов как её решить.
1. Убейте программу Linux, нажав «X»
Вы, наверное, уже пытались уйти и сделать горячий напиток. Если вы вернулись на свой компьютер и обнаружили, что приложение все еще зависло, вероятно, у него было достаточно времени, чтобы снова начать работать. Приложение, не отвечающее на запросы, обычно имеет серые кнопки или параметры, которые не работают. Вы также можете не перемещать окно приложения по экрану.
Итак, каково решение? Нажмите кнопку X в верхнем углу (слева или справа, в зависимости от графической оболочки в которой вы работаете и её настроек). Это должно остановить программу. Вы можете увидеть диалоговое окно с просьбой подождать или принудительно завершить процесс сейчас.
Если все пойдет по плану, некоторые дистрибутивы предложат вам отправить сообщение об ошибке.
2. Используйте системный монитор, чтобы убить процесс в Linux
Следующий вариант — открыть утилиту System Monitor вашей операционной системы Linux. Обычно это находится в меню «Системные инструменты» и отображает список запущенных процессов на вкладке «Процессы».
Чтобы закрыть не отвечающее приложение, просто выберите его и щелкните правой кнопкой мыши. Затем у вас есть три варианта:
- Остановить процесс: это приостанавливает процесс, позволяя продолжить его позже. Это не будет работать в большинстве случаев.
- Завершение процесса: правильный способ закрыть процесс, это безопасно завершит работу приложения, удаляя временные файлы в пути.
- Процесс уничтожения: это крайний вариант, и его следует использовать только в случае сбоя конечного процесса.
Лучше использовать их по порядку. Однако, если приложение регулярно зависает, вы можете использовать команду, которая, как вы знаете, работает.
3. Принудительно уничтожать процессы в Linux с помощью xkill
Другой вариант, который вы можете использовать — это xkill. Это инструмент принудительного уничтожения, предустановленный в Ubuntu, но вы можете установить его через терминал в других дистрибутивах, если это необходимо. При вызове xkill позволит вам закрыть любой процесс на рабочем столе. Установите его с помощью следующей команды:
Как только это будет сделано, запустите xkill, просто набрав
Ваш указатель мыши будет отображать крест (или череп). Щелкните левой кнопкой мыши на приложении-нарушителе, чтобы закрыть его.
Если невозможно закрыть приложение, не отвечающее на запросы, одним из этих методов, ориентированных на рабочий стол, решение может быть в командной строке…
4. Используйте команду «kill»
Если ваше приложение не отвечает, а приведенные выше предложения не работают (графический интерфейс может не отвечать), нажмите Ctrl+Alt+T, чтобы открыть Терминал.
Несколько параметров командной строки доступны, чтобы помочь вам закрыть ваше приложение. Более того, их можно использовать либо на вашем компьютере, либо подключившись через SSH с другого устройства.
Команда kill может использоваться здесь, но сначала требуется идентификатор процесса. Вы можете найти это, запустив команду, запрашивающую приложение для его идентификатора процесса:
В результате отобразится идентификатор процесса. Это может быть использовано следующим образом:
Обратите внимание, что вам может понадобиться добавить команду с помощью sudo.
5. Используйте «pgrep» и «pkill»
Что если вы не знаете или не можете найти идентификатор процесса? Вот тут и появляется команда pkill. Вместо идентификатора процесса просто используйте pkill вместе с именем процесса:
Кроме того, вы можете использовать команду pgrep, чтобы найти идентификатор процесса:
… И после этого используйте pkill с идентификатором процесса.
Как и в случае команды kill, процесс должен завершиться в течение 5 секунд.
6. Убить всё с помощью «killall»
Не повезло с kill или pkill? Пришло время использовать ядерную опцию: killall.
К счастью, это не так разрушительно, как могло бы быть. Команда killall завершит работу всех экземпляров указанной программы. Таким образом, вместо того, чтобы убивать одно окно Firefox, следующая команда завершит их все:
Все, что вам нужно, это имя процесса и команда killall (возможно, с sudo, если этого требует ваша система).
Естественно, вы должны использовать эту команду только при необходимости. Это не подходит для большинства не отвечающих программных ситуаций.
7. Создайте комбинацию клавиш Force-Kill
Хотите сэкономить время на закрытие не отвечающего программного обеспечения? Наилучшим вариантом является создание сочетания клавиш. Это даст вам немедленную возможность закрыть приложение, но для этого потребуется xkill.
В Ubuntu откройте Параметры > Устройства > Клавиатура и пролистайте список Комбинации клавиш в самый низ, где вы увидите «+». Нажимаем на «+», чтобы создать новый ярлык. В поля Имя и Команда введите «xkill», затем нажмите кнопку Установить комбинацию клавиш и введите нужную вам комбинацию и нажмите кнопку Добавить. Готово.
В следующий раз, когда вам нужно будет закрыть приложение, просто используйте сочетание клавиш. Указатель мыши станет X, и вы можете щелкнуть в любом месте приложения, которое хотите закрыть.
Избегайте не отвечающего программного обеспечения: обновите свое оборудование
Не отвечающие приложения регулярно вызывают проблемы? Возможно, вы могли бы получить выгоду от внесения некоторых изменений в свой компьютер с Linux.
Установка дополнительной оперативной памяти — это лучший способ повысить производительность вашего компьютера и возможно, именно это вам и нужно, чтобы эти темпераментные приложения перестали отвечать на запросы в будущем.
Итак, в следующий раз, когда приложение или утилита Linux зависнет и перестанет отвечать на запросы, все, что вам нужно сделать, это применить одно из следующих решений:
- Нажмите X в углу.
- Используйте системный монитор.
- Используйте приложение xkill.
- Используйте команду kill.
- Закройте приложения с помощью pkill.
- Используйте killall, чтобы закрыть программное обеспечение.
- Создайте сочетание клавиш.
Если ни одно из этих решений не работает и вы регулярно сталкиваетесь с не отвечающими приложениями в Linux, рассмотрите возможность перехода на облегченную операционную систему Linux.