Linux выполнить команду несколько раз

Как запускать команду Linux каждые X секунд навсегда

Вы когда-нибудь были в ситуации, когда вам приходилось несколько раз запускать определенную команду Linux?

Ну, если вы еще не знаете , этот учебник научит вас, как это сделать.

Конечно, вы можете сделать это, используя скрипт оболочки или задания cron.

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

Вот где команда Watch пригодится.

Эта команда может использоваться для повторного выполнения данной команды и контроля вывода в полноэкранном режиме.

Чтобы выразить это простыми словами, мы можем использовать команду Watch для запуска команды Linux каждые X секунд навсегда, и команда будет продолжать отображать вывод в консоли до тех пор, пока мы не остановим ее вручную, нажав CTRL + C, или убейте процесс или заставьте систему перезагрузится .

По умолчанию программа запускается каждые 2 секунды, или вы можете определить временной интервал по вашему выбору.

Запуск команды Linux каждые X секунд

Синтаксис команды watch:

Ниже я привел пять примеров, объясняющих, где вы можете использовать команду watch для повторного запуска определенных команд Linux.

Пример 1:

Скажем, вы хотите запустить команду «uptime» каждые 2 секунды, чтобы контролировать время безотказной работы вашей системы.

Для этого просто запустите:

• Every 2.0s: время безотказной работы – команда «uptime» запускается каждые 2 секунды и отображает результат.
• sk – текущий пользователь
• Wed Feb 9 20:14:46 2018 – текущая дата и время, когда мы выполнили команду.

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

Чтобы выйти из команды, нажмите CTRL + C.

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

Пример 2

Как я упоминал ранее, команда watch выполняет программу каждые 2 секунды по умолчанию.

Мы можем изменить его на определенный интервал, например 5 секунд, используя параметр -n.

Отобразим использование дискового пространства файловой системы каждые 5 секунд.

Чтобы проверить, действительно ли эта команда работает, создайте или удалите любой файл / папку.

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

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

Здесь флаг «-d или -differences» будет выделять различия между последовательными обновлениями.

Кроме того, вы можете отображать содержимое изменения каталога, которое принадлежит определенному пользователю ( например sk).

Это может быть полезно в многопользовательской системе.

Пример 4

Чтобы отобразить информацию о памяти, запустите:

Пример 5

Для отображения вывода команды du каждые 10 секунд вы можете использовать:

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

Заключение

Теперь вы знаете, как выполнять команду каждые X секунд с помощью команды «watch».

Как правило, команда Watch используется для мониторинга использования диска и использования памяти.

Не путайте эту команду с другими инструментами мониторинга.

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

Источник

Есть ли лучший способ запустить команду N раз в bash?

Я иногда запускаю командную строку bash следующим образом:

для выполнения some_command несколько раз подряд — 10 раз в этом случае.

часто some_command — это действительно цепочка команд или конвейер.

есть ли более лаконичный способ сделать это?

19 ответов

еще один простой способ взломать:

выполнить Эхо 20 раз.

обратите внимание, что seq 20 | xargs -Iz echo «Hi there z» выводит:

Если вы используете оболочку zsh:

где 10-Количество повторов команды.

используя GNU Parallel вы можете сделать:

Если вы не хотите номер в качестве аргумента и только запустить одно задание за раз:

пройдите через учебник (http://www.gnu.org/software/parallel/parallel_tutorial.html). Командная строка с любовью к тебе за это.

другая форма вашего примера:

xargs и быстро:

на современном 64-битном Linux, дает:

это имеет смысл, так как xargs команда-это единственный собственный процесс, который порождает /usr/bin/true команда несколько раз, вместо for и while петли, которые все интерпретируются в Bash. Конечно, это работает только для одной команды; если вам нужно сделать несколько команд в каждой итерации цикла, он будет так же быстро, или, может быть, быстрее, чем передача sh -c ‘command1; command2; . ‘ в xargs

на -P1 также можно изменить, скажем, -P8 чтобы порождать 8 процессов параллельно, чтобы получить еще один большой импульс в скорости.

Я не знаю, почему GNU parallel так медленно. Я бы подумал, что это сравнимо с xargs.

простая функция в файле конфигурации bash (.bashrc для меня, на Mac) может работать хорошо.

Источник

Выполнение сразу нескольких команд в командной строке

В командной строке Linux можно объединять сразу несколько команд в одну строку (в один запуск). Например, вам нужно выполнить сначала одну команду, за ней вторую и так далее. Но вы хотите сразу вбить в командной строке одну инструкцию, которая все сделает. Для этого можно воспользоваться служебными символами.

Выполнение команд последовательно

Например, мы хотим выполнить сначала одну команду. Затем, когда она отработает (вернет управление в командную строку), нам нужно запустить вторую команду. Для этого служит символ точка с запятой ;. Таким образом, если вы выполните в терминале:

то сначала запустится первая команда mycommand1, а когда управление вернется в терминал, то запустится вторая и так далее.

Для теста попробуйте выполнить (в Ubuntu):

Это называется последовательным выполнением команд. Вне зависимости от того, как выполнилась предыдущая команда, вторая команда должна будет запуститься. Можно выполнять команды в зависимости от того, как отработала предыдущая для этого служат символы && и ||.

Зависимое выполнение команд

Символы && и || означают не что иное, как логическое И и ИЛИ. Поэтому когда мы пишем:

то это означает, что команда mycommand2 будет выполнена только в том случае, если команда mycommand1 была выполнена успешно. Каждая следующая команда выполняется только при успешном выполнении предыдущей.

Если выполнить конструкцию:

то команда mycommand2 будет выполнена только, если mycommand1 вернула ошибку. Каждая следующая команда запускается только если предыдущая вернула ошибку.

Источник

🐧 Различные способы повторить вашу последнюю команду в Linux

Привет ! Сегодня я научу вас, как повторить вашу последнюю команду в Linux.

Вам не нужно повторно вводить ранее выполненные команды в вашей командной консоли.

Конечно, мы используем клавишу со стрелкой ВВЕРХ, чтобы выбрать последние выполненные команды, и нажимаем ENTER, чтобы выполнить их.

Однако есть и другие способы сделать это.

Может быть много способов повторить последние команды в Unix-подобных системах, но это единственные способы, которые я знаю в данный момнет.

Все эти команды были протестированы на моем настольном компьютере с Linux и Ubuntu 18.04 LTS с оболочкой BASH.

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

Как повторить вашу последнюю команду в Linux

Давайте сначала запустим несколько команд.

Как я упоминал ранее, мы можем выполнить последнюю команду, просто нажав стрелку ВВЕРХ и нажав клавишу Enter.

Это наиболее распространенный способ, используемый многими пользователями для выполнения предыдущей команды.

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

Однако, как я уже сказал, есть несколько других способов сделать это.

Теперь позвольте мне показать вам, как выполнить последнюю команду с некоторыми практическими примерами.

Метод 1 – Использование восклицательных знаков:

Чтобы выполнить любую последнюю выполненную команду, просто введите двойной восклицательный зна к и нажмите клавишу Enter:

Добавьте «sudo» перед «!!» чтобы выполнить последнюю команду от имени пользователя root, как показано ниже.

Эта команда также выполнит предыдущую команду:

Круто, не правда ли?

Вам не нужно вводить последнюю команду полностью.

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

Способ 2 – повторить N-ую команду:

Возможно, вы выполнили много команд и хотите повторить определенную команду.

Что вы будете делать?

Вы можете сделать это, набрав определенное слово предыдущей команды.

Чтобы повторить предыдущую команду, которая начинается с определенного слова / буквы, например, un, просто введите:

Приведенная выше команда выполнит последнюю команду, которая начинается с букв «un».

Пример вывода для вышеуказанной команды:

Как видите в приведенном выше примере, вам не нужно вводить всю команду (т.е. uname -r).

Вместо этого просто введите несколько букв команды, и любая предыдущая команда, содержащая слова, будет выполняться.

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

Система выполнит последнюю команду.

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

Иногда вам не нужно запускать команду, а просто извлечь ее из истории.

Если это так, найдите префикс номера команды, которую вы хотите выполнить:

Метод 3 – Использование обратного поиска:

Другой способ сделать это – поиск в истории командной строки с помощью сочетания клавиш CTRL + R.

Нажмите клавиши CTRL + R для поиска по истории командной строки.

Я лично предпочитаю этот метод.

Он ищет историю в интерактивном режиме, что, на мой взгляд, безопаснее, чем слепое выполнение команд из истории BASH.

Посмотрите на следующий пример.

В следующем примере я искал «itsec», и система показала последнюю команду «sudo netctl restart itsecforu» в истории, которая содержала слово «itsec»

Затем я нажимаю клавишу Enter для немедленного выполнения команды или клавишу со стрелкой вправо для завершения команды и нажимаю клавишу Enter для ее выполнения.

На всякий случай, если вы хотите отредактировать / изменить последнюю команду перед ее выполнением, просто нажмите клавишу со стрелкой влево, затем отредактируйте последнюю команду и нажмите ENTER, чтобы выполнить ее.

Некоторые команды могут начинаться с одинаковых букв.

В таких случаях продолжайте нажимать клавиши CTRL + R, чтобы вернуть команду, которую вы хотели выполнить.

Метод 4 – Используя символ дефиса с номерами префикса команды:

Вот еще один способ выполнить предыдущую команду.

Способ 5 – Использование CTRL + p и CTRL + o:

Я не хочу вводить какие-либо команды вручную.

Есть ли способ повторить последнюю команду простым нажатием определенной клавиши (клавиш) на моей клавиатуре? Да, конечно!

Нажмите CTRL + P, чтобы перейти к последней команде, а затем нажмите CTRL + O, чтобы выполнить ее.

Вы можете использовать CTRL + O столько раз, сколько вы хотите, чтобы продолжить повторное выполнение последних команд.

Способ 6 – Использование команды «fc»:

Это еще один способ повторить последнюю выполненную команду.

Команда «fc» используется для просмотра, редактирования и повторного ввода ранее введенной команды.

Чтобы повторить последнюю команду, используя fc, просто запустите:

На это пока все.

Теперь вы знаете, как повторить последнюю команду, не вводя ее в терминале.

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

Если вы знаете какие-либо другие методы, пожалуйста, дайте мне знать в разделе комментариев ниже.

Я проверю и обновлю руководство с вашими дополнениями.

Источник

Кунг-фу стиля Linux: запуск команд

Одна из особенностей Linux- и Unix-подобных операционных систем, возможность мощная, но, в то же время, вызывающая немало путаницы, заключается в том, что в этих системах до одной и той же цели можно добраться разными путями. Возьмём, например, что-то простое, вроде запуска последовательностей команд. Как это сделать? Пожалуй, самый очевидный ответ на этот вопрос заключается в написании shell-скрипта. Это — потрясающе гибкий подход к решению подобной задачи. Но что если нужно всего лишь запустить несколько команд, по возможности ничем не усложняя себе жизнь? Выглядит такая задача весьма простой, но существует множество способов решить её — от простого ввода этих команд в командной строке, до планирования их запуска. За выполняющимися командами, кроме того, можно наблюдать, организовав мониторинг очереди задач так, как он может быть организован на мейнфрейме.

Поговорим о запуске команд в Linux, рассмотрим несколько способов запуска последовательностей команд из bash (и из многих других оболочек Linux). Здесь мы коснёмся таких вопросов, как использование утилит cron и at , поговорим о системе пакетного выполнения команд с использованием очереди (task spooler). Я, как и в большинстве случаев обсуждения возможностей Linux, не могу сказать, что то, о чём я хочу рассказать, хотя бы близко подходит к полному освещению способов запуска команд в Linux. Но я надеюсь, что мой рассказ даст вам некоторые идеи относительно управления выполнением последовательностей команд.

Запуск команд из командной оболочки

Самый простой, хотя, возможно, не самый красивый способ запуска набора команд заключается в использовании обычной командной оболочки. Для этого команды достаточно разделить точкой с запятой:

Этот приём работает в большинстве командных оболочек, которые более или менее похожи на bash. Он хорошо подходит для запуска простого набора команд. Команды просто выполняются последовательно. Но что если надо запустить нечто вроде такой конструкции:

Не запускайте эту последовательность команд в реальной системе!

Нам нужно стереть в папке foo все файлы (но не подпапки — для этого нужен ключ -r ). А что если не удастся выполнить команду cd ? Тогда будут стёрты все файлы в текущей папке. А это — очень плохая идея, которая, к тому же, нарушает правило наименьшего удивления.

Защититься от вышеописанной проблемы можно, воспользовавшись оператором && . Эта последовательность символов, как и в языке C, представляет собой оператор И . Практически все Linux-команды возвращают, успешно отработав, 0, что воспринимается как истинное значение, а все остальные значения, указывающие на ошибки, считаются ложными. Это позволяет программистам возвращать коды ошибок при возникновении в программах каких-то проблем. Вот более удачный вариант вышеописанного примера:

Если директория foo существует — команда cd вернёт 0, который будет воспринят как истинное значение. Это означает, что результат операции И может быть истинным. Поэтому работа продолжается и выполняется команда ls . А вот если команду cd выполнить не удастся — результат будет ложным. Если любое из входных значений функции, реализующей логику оператора И , является ложным, то остальные входные значения роли уже не играют. В результате если хотя бы одна из частей этой конструкции вернёт ложное значение — выполнение всей последовательности команд будет остановлено. Получается, что если директории /foo не существует — команда ls попросту не выполнится.

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

Более длинная конструкция, в которой используется && (тут тоже есть rm, поэтому будьте очень осторожны, пытаясь запустить нечто подобное в реальной системе)

В ситуациях, подобных вышеописанной, может найти применение ещё один оператор — || ( ИЛИ ). Он позволяет завершить работу после того, как хотя бы одна команда вернёт истинное значение, то есть — отработает успешно. Например:

Попробуйте, вместо alw , ввести своё имя пользователя, а потом испытайте эту конструкцию с именем пользователя, которого в вашей системе нет (уверен, у вас нет пользователя alw ). Если grep отработает успешно, то команда echo выполнена не будет.

Если нужно — операторы можно смешивать. Правда, если вам нужно выполнить несколько команд, выполнение которых занимает много времени, то, о чём мы только что говорили, нельзя назвать самым удачным способом запуска таких команд. В подобной ситуации стоит взглянуть на систему пакетного выполнения команд, основанную на очереди задач, речь о которой пойдёт ниже.

Планирование запуска команд в определённое время

Иногда нужно, чтобы последовательность команд запустилась бы спустя некоторое время от текущего момента, или чтобы команды были бы выполнены в заданное время. Классический инструмент, используемый для решения подобных задач — это утилита cron . Во многих дистрибутивах есть стандартные директории, позволяющие запускать команды, например, каждый час или каждую минуту. Но лучше всего планировать запуск команд путём редактирования файла crontab . Обычно сначала создают скрипт, а потом уже делают запись о нём в crontab . Правда, необходимость в создании скрипта для запуска нескольких команд возникает далеко не всегда.

Файл crontab редактируют, пользуясь одноимённой командой ( crontab -e ). Каждая строка этого файла, не являющаяся комментарием, описывает некую команду, которую нужно выполнить. Первая часть такого описания сообщает о том, когда именно нужно выполнить команду. Вторая часть содержит указание на саму команду. Например, вот запись, позволяющая запустить команду обновления duckdns:

В начале строки находится описание времени запуска команды — минуты, час, день месяца, день недели. Конструкция */5 указывает на то, что команду нужно запускать каждые 5 минут. Символы * являются универсальными местозаполнителями, представляющими любой час, день месяца и так далее. Есть множество особых конструкций, которыми можно пользоваться в подобных описаниях. Для того чтобы упростить их составление — можете попробовать этот crontab-редактор. Пример работы с ним показан ниже.

Работа с crontab-редактором

Правда, при использовании cron можно столкнуться с одной проблемой. Она заключается в том, что логика утилиты основана на предположении о том, что компьютер работает в режиме 24/7. Так, если запланировать запуск некоей задачи на ночь, а ночью компьютер будет выключен — задача выполнена не будет. Есть ещё одна утилита, anacron , которая создана в попытке исправить этот недостаток. Она, учитывая некоторые ограничения, похожа на cron , но она «навёрстывает упущенное» в том случае, если на момент запланированного запуска некоей задачи компьютер был выключен.

Иногда нужно выполнить некую команду в заданное время лишь один раз. Сделать это можно с помощью команды at :

В ответ на эту команду будет показано простое приглашение командной строки, с помощью которого можно вводить команды. В данном случае эти команды будут выполнены через 10 минут. Эта команда, конечно, поддерживает и указание абсолютных временных значений. Кроме того, программа вас поймёт, если вы вместо 4PM сообщите ей о «teatime» (серьёзно). Команда atq позволяет просмотреть список запланированных задач. А команда atrm позволяет отменять запуск запланированных команд. Это пригодится в том случае, если по какой-то причине в выполнении запланированной команды больше нет необходимости. Если воспользоваться пакетной формой команды ( batch ), система выполнит команды тогда, когда нагрузка на неё будет не слишком высокой.

Если почитать справку по at , то можно узнать о том, что утилита, по умолчанию, использует очередь a для обычных задач, а очередь b для пакетных задач. Для указания очередей можно использовать буквы из диапазонов a-z и A-Z. От имени очереди зависит приоритет помещённых в неё задач.

Тут мне хотелось бы отметить то, что в большинстве систем все задачи, поставленные в очередь, будут выполняться в оболочке, заданной как оболочка, используемая по умолчанию (вроде /bin/sh ), и это необязательно будет bash. Может понадобиться использовать именно bash, или протестировать команды в оболочке, используемой по умолчанию. Если просто запустить скрипт, в котором, в качестве интерпретатора указан bash (например — #!/usr/bin/bash ), то это будет незаметно.

Пакетное выполнение задач

Хотя утилита at имеет вариант, выглядящий как batch , её нельзя назвать полноценной системой, предназначенной для пакетного выполнения задач. Существует несколько подобных систем для Linux, обладающих различными особенностями. Одна из таких систем называется Task Spooler (в репозиториях Ubuntu — task-spooler ). В некоторых системах соответствующая команда выглядит как ts , но в Debian использование подобного имени команды приводит к конфликту, поэтому там используется команда tsp .

Команду tsp применяют, указывая при её вызове описание той задачи, которую нужно выполнить. Она возвращает номер задачи, который можно использовать при планировании зависимостей между задачами. Всё это похоже на использование утилиты at , но эта система отличается гораздо более мощными возможностями. Взгляните на это:

Первая команда запускает, в виде задачи, утилиту wget (это, на самом деле, задача 0). Выполнение команды tsp позволяет просмотреть список задач, находящихся в очереди (в данном случае это — всего одна задача, которая уже завершена). Опция -i позволяет просмотреть сведения об указанных задачах. Опция -c выводит выходные данные задачи. Опцию -c можно воспринимать как нечто вроде команды cat . Ещё одна опция, -t , похожа на опцию -f команды tail . Выходные данные задачи можно, кроме того, отправить по электронной почте, воспользовавшись опцией -m .

Обычно система пакетного выполнения задач выполняет одновременно лишь одну задачу. Это можно изменить, воспользовавшись опцией -S . Можно сделать так, чтобы некая задача ожидала бы, перед запуском, окончания работы предыдущей задачи. Это делается с помощью опции -d . Запуск задачи можно связать и с окончанием произвольно выбранной задачи — для этого используется опция -w .

Если вы читали справку по tsp , то вы могли обратить внимание на то, что эта команда поддерживает и множество других опций. Перед тем, как воспользоваться этой командой в некоей системе, стоит помнить о том, что она может выглядеть не как tsp , а как ts . Примеры использования этой утилиты можно найти на её сайте.

Итоги

Как и во многих других ситуациях, возникающих при работе в Linux, вышеописанные способы запуска наборов команд можно комбинировать. Например, можно сделать так, чтобы cron поставил бы задачу в очередь. А сама эта задача может представлять собой скрипт, в котором применяются операторы && и || , управляющие внутренней логикой выполнения набора команд. Думаете, что это неоправданно сложно? Может быть. Как я уже говорил, можно просто взять и написать обычный скрипт. Но в Linux есть и много других полезных механизмов для решения самых разных задач.

Как вы обычно запускаете наборы команд в Linux?

Источник