Répéter une commande Unix toutes les x secondes pour toujours

Il existe une commande Unix intégrée repeatdont le premier argument est le nombre de répétitions d'une commande, la commande (avec tous les arguments) étant spécifiée par les arguments restants repeat.

Par exemple,

% repeat 100 echo "I will not automate this punishment."

fera écho la chaîne donnée 100 fois puis s'arrêtera.

J'aimerais une commande similaire - appelons-la forever- qui fonctionne de la même manière, sauf que le premier argument est le nombre de secondes de pause entre les répétitions et qu'il se répète indéfiniment. Par exemple,

% forever 5 echo "This will get echoed every 5 seconds forever and ever."

Je pensais demander si une telle chose existait avant de l'écrire. Je sais que c'est comme un script Perl ou Python à 2 lignes, mais il existe peut-être une méthode plus standard pour le faire. Si ce n'est pas le cas, n'hésitez pas à poster une solution dans votre langage de script préféré, à la manière de Rosetta Stone .

PS: Une meilleure façon de procéder serait peut-être de généraliser repeaten prenant à la fois le nombre de répétitions (-1 signifiant l'infini) et le nombre de secondes de veille entre les répétitions. Les exemples ci-dessus deviendraient alors:

% repeat 100 0 echo "I will not automate this punishment."
% repeat -1 5 echo "This will get echoed every 5 seconds forever."

Essayez la watchcommande.

Usage: watch [-dhntv] [--differences[=cumulative]] [--help] [--interval=<n>] 
             [--no-title] [--version] <command>`

Pour que:

watch -n1  command

exécutera la commande toutes les secondes (enfin, techniquement, toutes les secondes plus le temps nécessaire commandà l'exécution de watch(au moins, les implémentations procpset busybox) dort une seconde entre deux exécutions command), pour toujours.

Souhaitez-vous passer la commande à la execplace de sh -c, utilisez l' -xoption:

watch -n1 -x command

Sur macOS, vous pouvez obtenir watchdes ports Mac :

port install watch

Ou vous pouvez l'obtenir de Homebrew :

brew install watch

Frapper

while+ sleep:

while true
do 
    echo "Hi"
    sleep 1
done

Voici la même chose qu'un raccourci One-Liner (d'après les commentaires ci-dessous):

while sleep 1; do echo "Hi"; done

Utilise ;pour séparer les commandes et utilise sleep 1pour le whiletest puisqu'il renvoie toujours true. Vous pouvez mettre plus de commandes dans la boucle - séparez-les simplement avec;

Ceci est juste une version abrégée d’autres while+sleepréponses, si vous exécutez ce type de tâches souvent comme votre routine quotidienne, vous évitez ainsi d’appuyer sur des touches inutiles et si votre ligne de commande commence à être plus longue, sachant que celle-ci est un peu plus facile. Mais celui-ci commence par dormir en premier.

Ceci est généralement utile si vous devez suivre quelque chose qui a une sortie sur une ligne, telle que la charge de la machine:

while sleep 1; do uptime; done

Un problème que toutes les réponses postées jusqu'à présent ont, c'est que le temps d'exécution de la commande peut dériver. Par exemple, si vous faites une sleep 10commande entre deux et que la commande prend 2 secondes pour s'exécuter, elle s'exécutera toutes les 12 secondes. s'il faut un temps variable pour s'exécuter, le temps d'exécution peut être imprévisible à long terme.

Cela pourrait être juste ce que vous voulez; si tel est le cas, utilisez l’une des autres solutions ou utilisez-la, mais simplifiez l’ sleepappel.

Pour une résolution d'une minute, les tâches cron seront exécutées à l'heure spécifiée, quelle que soit la durée de chaque commande. (En fait, un nouveau travail cron sera lancé même si le précédent est toujours en cours d'exécution.)

Voici un script Perl simple qui dort jusqu'à l'intervalle suivant. Ainsi, par exemple, avec un intervalle de 10 secondes, la commande peut s'exécuter à 12:34:00, 12:34:10, 12:34:20, etc., même si le La commande elle-même prend plusieurs secondes. Si la commande s'exécute plus de intervalsecondes, l'intervalle suivant sera ignoré (contrairement à cron). L'intervalle étant calculé par rapport à l'époque, un intervalle de 86 400 secondes (1 jour) sera exécuté à minuit UTC.

#!/usr/bin/perl

use strict;
use warnings;

if (scalar @ARGV < 2) {
    die "Usage: $0 seconds command [args...]\n";
}

$| = 1;  # Ensure output appears

my($interval, @command) = @ARGV;

# print ">>> interval=$interval command=(@command)\n";

while (1) {
    print "sleep ", $interval - time % $interval, "\n";
    sleep $interval - time % $interval;
    system @command; # TODO: Handle errors (how?)
}

Je pense que toutes les réponses à ce jour sont soit trop compliquées, soit répondent à une question différente:

• "Comment faire pour exécuter un programme à plusieurs reprises afin qu'il y ait un délai de X secondes entre la fin du programme et le prochain démarrage" .

La vraie question était:

• "Comment exécuter un programme toutes les X secondes"

Ce sont deux choses très différentes lorsque la commande met du temps à se terminer.

Prenons par exemple le script foo.sh(supposons qu'il s'agit d'un programme qui prend quelques secondes à terminer).

#!/bin/bash
# foo.sh
echo `date +"%H:%M:%S"` >> output.txt;
sleep 2.5;
# ---

Vous souhaitez exécuter cela toutes les secondes, et la plupart suggèrent watch -n1 ./foo.sh, ou while sleep 1; do ./foo.sh; done. Cependant, cela donne la sortie:

15:21:20
15:21:23
15:21:27
15:21:30
15:21:34

Ce qui ne se fait pas exactement à chaque seconde. Même avec le -pdrapeau, comme le man watchsuggère la page, le résultat est le même.

Un moyen facile d'accomplir la tâche souhaitée, que certains abordent, consiste à exécuter la commande en arrière-plan. En d'autres termes:

while sleep 1; do (./foo.sh &) ; done

Et c'est tout ce qu'il y a à faire.

Vous pouvez l'exécuter toutes les 500 ms avec sleep 0.5, ou ce que vous avez.

Dans bash:

bash -c 'while [ 0 ]; do echo "I will not automate this punishment in absurdum."; done'

( echopourrait être remplacé par n'importe quelle commande ...

Ou dans perl:

perl -e 'for (;1;) {print "I will not automate this punishment in absurdum.\n"}'

Où print "I will not automate this punishment in absurdum.\n"pourrait être remplacé par "toute" commande entourée de backticks (`).

Et pour une pause, ajoutez une sleepdéclaration dans la boucle for:

bash -c 'while [ 0 ]; do echo "I will not automate this punishment in absurdum."; sleep 1; done'

et

perl -e 'for (;1;) {print "I will not automate this punishment in absurdum.\n"; sleep 1}'

Recent bash> = 4.2 sous noyau récent, réponse basée.

Afin de limiter le temps d'exécution, il n'y a pas de fourches ! Seuls les éléments intégrés sont utilisés.

Pour cela, readj'utilise la fonction intégrée au lieu de sleep. Unfortunely cela ne fonctionnera pas avec Notty sessions.

Fonction bash rapide " repeat" à la demande:

repeat () {
   local repeat_times=$1 repeat_delay=$2 repeat_foo repeat_sleep
   read -t .0001 repeat_foo
   if [ $? = 1 ] ;then
       repeat_sleep() { sleep $1 ;}
   else
       repeat_sleep() { read -t $1 repeat_foo; }
   fi
   shift 2
   while ((repeat_times)); do
        ((repeat_times=repeat_times>0?repeat_times-1:repeat_times))
        "${@}"
        ((repeat_times))&& ((10#${repeat_delay//.})) &&
            repeat_sleep $repeat_delay
   done
}

Petit test avec des chaînes citées:

repeat 3 0 printf "Now: %(%T)T, Hello %s.\n" -1 Guy
Now: 15:13:43, Hello Guy.
Now: 15:13:43, Hello Guy.
Now: 15:13:43, Hello Guy.

repeat -1 .5 printf "Now: %(%T)T, Hello %s.\n" -1 Guy
Now: 15:14:14, Hello Guy.
Now: 15:14:14, Hello Guy.
Now: 15:14:15, Hello Guy.
Now: 15:14:15, Hello Guy.
Now: 15:14:16, Hello Guy.
Now: 15:14:16, Hello Guy.
Now: 15:14:17, Hello Guy.
Now: 15:14:17, Hello Guy.
Now: 15:14:18, Hello Guy.
Now: 15:14:18, Hello Guy.
^C

En fonction de la granularité et de la durée de la commande soumise ...

Dans les noyaux Linux récents, il existe un fichier procfile /proc/timer_listcontenant des informations de temps en nanosecondes.

Si vous voulez exécuter une commande exactement une fois par seconde, votre commande doit se terminer en moins d'une seconde! Et à partir de là, il sleepne reste que le reste de la seconde actuelle.

Si le délai est plus important et que votre commande ne nécessite pas beaucoup de temps, vous pouvez:

command=(echo 'Hello world.')
delay=10
while :;do
    printf -v now "%(%s)T" -1
    read -t $(( delay-(now%delay) )) foo
    ${command[@]}
  done.

Mais si votre objectif est d’obtenir une granularité plus fine, vous devez:

Utilisez les informations en nanosecondes pour attendre le début d'une seconde ...

Pour cela, j'ai écrit une petite fonction bash:

# bash source file for nano wait-until-next-second

mapfile  </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
    ((_c+=${#_timer_list[_i]}))
    [[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_READ=$_c
    [[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
        TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
        break
done
unset _i _timer_list _c
readonly TIMER_LIST_OFFSET TIMER_LIST_READ
waitNextSecondHires() {
    local nsnow nsslp
    read -N$TIMER_LIST_READ nsnow </proc/timer_list
    nsnow=${nsnow%% nsecs*}
    nsnow=$((${nsnow##* }+TIMER_LIST_OFFSET))
    nsslp=$((2000000000-10#${nsnow:${#nsnow}-9}))
    read -t .${nsslp:1} foo
}

Après les avoir achetés, vous pourriez:

command=(echo 'Hello world.')
while :;do
    waitNextSecondHires
    ${command[@]}
  done.

exécuter ${command[@]}directement en ligne de commande, que comparer à

command=(eval "echo 'Hello world.';sleep .3")
while :;do
    waitNextSecondHires
    ${command[@]}
  done.

cela doit donner exactement le même résultat.

Engage la fonction bash " repeat" à la demande:

Vous pourriez trouver ceci:

mapfile  </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
    ((_c+=${#_timer_list[_i]}))
    [[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_READ=$_c
    [[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
        TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
        break
done
unset _i _timer_list _c
readonly TIMER_LIST_OFFSET TIMER_LIST_READ

repeat_hires () {
    local repeat_times=$1 repeat_delay=$2 repeat_foo repeat_sleep repeat_count
    read -t .0001 repeat_foo
    if [ $? = 1 ] ;then
        repeat_sleep() { sleep $1 ;}
    else
        repeat_sleep() { read -t $1 repeat_foo; }
    fi
    shift 2
    printf -v repeat_delay "%.9f" $repeat_delay
    repeat_delay=${repeat_delay//.}
    read -N$TIMER_LIST_READ nsnow </proc/timer_list
    nsnow=${nsnow%% nsec*}
    started=${nsnow##* }
    while ((repeat_times)); do
        ((repeat_times=repeat_times>0?repeat_times-1:repeat_times))
        "${@}"
        ((repeat_times)) && ((10#$repeat_delay)) && {
            read -N$TIMER_LIST_READ nsnow </proc/timer_list
            nsnow=${nsnow%% nsec*}
            nsnow=${nsnow##* }
            (( (nsnow - started) / 10#$repeat_delay - repeat_count++ )) &&
                printf >&2 "WARNING: Command '%s' too long for %f delay.\n" \
                           "${*}" ${repeat_delay:0:${#repeat_delay}-9
                           }.${repeat_delay:${#repeat_delay}-9}
            printf -v sleep "%010d" $((
                10#$repeat_delay - ( ( nsnow - started ) % 10#$repeat_delay ) ))
            repeat_sleep ${sleep:0:${#sleep}-9}.${sleep:${#sleep}-9}
        }
    done
}

Alors essayez-le:

time repeat_hires 21 .05 sh -c 'date +%s.%N;sleep .01'
1480867565.152022457
1480867565.201249108
1480867565.251333284
1480867565.301224905
1480867565.351236725
1480867565.400930482
1480867565.451207075
1480867565.501212329
1480867565.550927738
1480867565.601199721
1480867565.651500618
1480867565.700889792
1480867565.750963074
1480867565.800987954
1480867565.853671458
1480867565.901232296
1480867565.951171898
1480867566.000917199
1480867566.050942638
1480867566.101171249
1480867566.150913407

real    0m1.013s
user    0m0.000s
sys     0m0.016s

time repeat_hires 3 .05 sh -c 'date +%s.%N;sleep .05'
1480867635.380561067
WARNING: Command 'sh -c date +%s.%N;sleep .05' too long for 0.050000 delay.
1480867635.486503367
WARNING: Command 'sh -c date +%s.%N;sleep .05' too long for 0.050000 delay.
1480867635.582332617

real    0m0.257s
user    0m0.000s
sys     0m0.004s

Tu veux essayer ça (Bash)?

forever ()   {
    TIMES=shift;
    SLEEP=shift;
    if [ "$TIMES" = "-1" ]; then  
        while true;
        do 
            $@
            sleep $SLEEP
        done
    else
        repeat "$TIMES" $@ 
    fi; }

Perl

#!/usr/bin/env perl
# First argument is number of seconds to sleep between repeats, remaining
# arguments give the command to repeat forever.

$sleep = shift;
$cmd = join(' ', @ARGV);

while(1) {
  system($cmd);
  sleep($sleep); 
}

Bash et certains de ses shells apparentés ont la (( ... ))notation pratique dans laquelle les expressions arithmétiques peuvent être évaluées.

Donc, pour répondre à votre troisième défi, où le nombre de répétitions et le délai entre chaque répétition doivent être configurables, voici une façon de le faire:

repeat=10
delay=1

i=0
while (( i++ < repeat )); do
  echo Repetition $i
  sleep $delay
done

Cette réponse souffre également de la dérive de synchronisation couverte par la réponse de Keith .

Comme mentionné par gbrandt, si la watchcommande est disponible, utilisez-la. Cependant, certains systèmes Unix ne l’ont pas installé par défaut (du moins, ils ne le sont pas où je travaille).

Voici une autre solution avec une syntaxe et une sortie légèrement différentes (fonctionne sous BASH et SH):

while [ 1 ] ; do
    <cmd>
    sleep <x>
    echo ">>>>>>>>>>>>>" `date` ">>>>>>>>>>>>>>"
done

Edit: j'ai enlevé des "." dans la dernière déclaration d'écho ... le reste de mes jours Perl;)

Si votre intention n'est pas d'afficher un message sur votre écran et si vous pouviez vous permettre de répéter le travail en minutes, crontab serait peut-être votre meilleur outil. Par exemple, si vous souhaitez exécuter votre commande toutes les minutes, vous écrirez quelque chose comme ceci dans votre crontabfichier:

* * * * * my_precious_command

S'il vous plaît consulter le tutoriel pour plus d'exemple. En outre, vous pouvez facilement définir les minutages à l’aide de Crontab Code Generator .

Et si on avait les deux?

Voici l’idée: avec seulement "intervalle", cela se répète pour toujours. Avec "intervalle" et "fois", il répète ce nombre de fois, séparé par "intervalle".

L'usage :

$ loop [interval [times]] command

Donc, l'algorithme sera:

• Élément de liste
• si $ 1 ne contient que des chiffres, c'est l'intervalle (2 par défaut)
• si $ 2 ne contient que des chiffres, c'est le nombre de fois (infini par défaut)
• boucle while avec ces paramètres
  • sommeil "intervalle"
  • si un nombre de fois donné a été donné, décrémente un var jusqu'à ce qu'il soit atteint

Par conséquent :

loop() {
    local i=2 t=1 cond

    [ -z ${1//[0-9]/} ] && i=$1 && shift
    [ -z ${1//[0-9]/} ] && t=$1 && shift && cond=1
    while [ $t -gt 0 ]; do 
        sleep $i
        [ $cond ] && : $[--t]
        $@
    done
}

J'ai fini par créer une variante sur la réponse de swalog. Avec le sien, vous deviez attendre X secondes pour la première itération, je cours aussi au premier plan alors ..

./foo.sh;while sleep 1; do (./foo.sh) ; done

Rapide, sale et probablement dangereux pour démarrer, mais si vous êtes aventureux et savez ce que vous faites, mettez cela en repeat.shet chmod 755il,

while true
do 
    eval $1 
    sleep $2 
done

Invoquer avec ./repeat.sh <command> <interval>

Mon sens spidey dit que c'est probablement une façon perverse de faire cela. Mon sens spidey est-il correct?

Vous pouvez exécuter un script à partir d'init (en ajoutant une ligne à / etc / inittab). Ce script doit exécuter votre commande, patientez pendant le temps que vous souhaitez attendre jusqu'à ce qu'il soit exécuté à nouveau et quittez-le. Init lancera votre script à nouveau après la sortie.

Un moyen facile de répéter un travail à partir de crontab avec un intervalle inférieur à une minute (exemple de 20 secondes):

crontab: * * * * * script.sh

script.sh:

#!/bin/bash
>>type your commands here.

sleep 20
>>retype your commands here.

sleep 20
>>retype your commands here.

Vous pouvez obtenir le pouvoir de l'interpréteur python de shell.

python3 -c "import time, os
while True:
    os.system('your command')
    time.sleep(5)

remplacez-en cinq en tout temps (sec) que vous aimez.

Attention: le retour utilise SHIFT + ENTER pour renvoyer une entrée en shell. Et n'oubliez pas de taper 4 SPACE indent dans chaque ligne de la boucle while.

Cette solution fonctionne sous MacOSX 10.7. Cela fonctionne à merveille.

bash -c 'while [ 0 ]; do \
      echo "I will not automate this punishment in absurdum."; done'

Dans mon cas

bash -c 'while [ 0 ]; do ls; done'

ou

bash -c 'while [ 0 ]; do mv "Desktop/* Documents/Cleanup"; done'

nettoyer mon bureau en permanence.

Vous pouvez source cette fonction récursive:

#!/bin/bash
ininterval () {
    delay=$1
    shift
    $*
    sleep $delay
    ininterval $delay $*
}

ou ajouter un:

ininterval $*

et appelez le script.

Pour exécuter de manière répétée une commande dans une fenêtre de console, je lance généralement quelque chose comme ceci:

while true; do (run command here); done

Cela fonctionne également pour plusieurs commandes, par exemple pour afficher une horloge continuellement mise à jour dans une fenêtre de console:

while true; do clear; date; sleep 1; done

#! /bin/sh

# Run all programs in a directory in parallel
# Usage: run-parallel directory delay
# Copyright 2013 by Marc Perkel
# docs at http://wiki.junkemailfilter.com/index.php/How_to_run_a_Linux_script_every_few_seconds_under_cron"
# Free to use with attribution

if [ $# -eq 0 ]
then
   echo
   echo "run-parallel by Marc Perkel"
   echo
   echo "This program is used to run all programs in a directory in parallel" 
   echo "or to rerun them every X seconds for one minute."
   echo "Think of this program as cron with seconds resolution."
   echo
   echo "Usage: run-parallel [directory] [delay]"
   echo
   echo "Examples:"
   echo "   run-parallel /etc/cron.20sec 20"
   echo "   run-parallel 20"
   echo "   # Runs all executable files in /etc/cron.20sec every 20 seconds or 3 times a minute."
   echo 
   echo "If delay parameter is missing it runs everything once and exits."
   echo "If only delay is passed then the directory /etc/cron.[delay]sec is assumed."
   echo
   echo 'if "cronsec" is passed then it runs all of these delays 2 3 4 5 6 10 12 15 20 30'
   echo "resulting in 30 20 15 12 10 6 5 4 3 2 executions per minute." 
   echo
   exit
fi

# If "cronsec" is passed as a parameter then run all the delays in parallel

if [ $1 = cronsec ]
then
   $0 2 &
   $0 3 &
   $0 4 &
   $0 5 &
   $0 6 &
   $0 10 &
   $0 12 &
   $0 15 &
   $0 20 &
   $0 30 &
   exit
fi

# Set the directory to first prameter and delay to second parameter

dir=$1
delay=$2

# If only parameter is 2,3,4,5,6,10,12,15,20,30 then automatically calculate 
# the standard directory name /etc/cron.[delay]sec

if [[ "$1" =~ ^(2|3|4|5|6|10|12|15|20|30)$ ]]
then
   dir="/etc/cron.$1sec"
   delay=$1
fi

# Exit if directory doesn't exist or has no files

if [ ! "$(ls -A $dir/)" ]
then
   exit
fi

# Sleep if both $delay and $counter are set

if [ ! -z $delay ] && [ ! -z $counter ]
then
   sleep $delay
fi

# Set counter to 0 if not set

if [ -z $counter ]
then
   counter=0
fi

# Run all the programs in the directory in parallel
# Use of timeout ensures that the processes are killed if they run too long

for program in $dir/* ; do
   if [ -x $program ] 
   then
      if [ "0$delay" -gt 1 ] 
      then
         timeout $delay $program &> /dev/null &
      else
         $program &> /dev/null &
      fi
   fi
done

# If delay not set then we're done

if [ -z $delay ]
then
   exit
fi

# Add delay to counter

counter=$(( $counter + $delay ))

# If minute is not up - call self recursively

if [ $counter -lt 60 ]
then
   . $0 $dir $delay &
fi

# Otherwise we're done

Avec zshet une sleepimplémentation qui accepte les arguments en virgule flottante:

typeset -F SECONDS=0 n=0
repeat 100 {cmd; sleep $(((n+=3) - SECONDS))}

Ou pour forever:

for ((;;)) {cmd; sleep $(((n+=3) - SECONDS))}

Si votre sleepne supporte pas les float, vous pouvez toujours le redéfinir en tant que wrapper autour zshde zselect:

zmodload zsh/zselect
sleep() zselect -t $((($1 * 100) | 0))

... Je me demande combien de solutions compliquées peuvent être créées pour résoudre ce problème.

Cela peut être si facile ...

open /etc/crontab 

mettez-y 1 ligne suivante à la fin du fichier comme:

*/NumberOfSeconds * * * * user /path/to/file.sh

Si vous voulez exécuter quelque chose toutes les 1 secondes, mettez-y simplement:

*/60 * * * * root /path/to/file.sh 

where that file.sh could be chmod 750 /path/to/file.sh

et à l'intérieur de ce fichier.sh devrait être:

#!/bin/bash 
#What does it do
#What is it runned by

your code or commands

et c'est tout!

PRENDRE PLAISIR!

until ! sleep 60; do echo $(date); command; command; command; done

travaille pour moi.

1. Je n'en ai pas besoin exactement toutes les 60 secondes
2. "watch" ne regarde pas les commandes sur tous les systèmes
3. "watch" ne peut prendre qu'une seule commande (ou un fichier de script)
4. mettre le sommeil dans l'état au lieu du corps rend la boucle plus facilement interruptible (donc une réclamation dans une réponse à une question similaire sur stackoverflow. Malheureusement, je ne le trouve pas pour le moment)
5. Je veux l'exécuter une fois avant le délai, donc je l'utilise jusqu'au lieu de