Repeat a Unix command every x seconds forever

Question 1

There's a built-in Unix command repeat whose first argument is the number of times to repeat a command, where the command (with any arguments) is specified by the remaining arguments to repeat.

For example,

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

will echo the given string 100 times and then stop.

I'd like a similar command – let's call it forever – that works similarly except the first argument is the number of seconds to pause between repeats, and it repeats forever. For example,

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

I thought I'd ask if such a thing exists before I write it. I know it's like a 2-line Perl or Python script, but maybe there's a more standard way to do this. If not, feel free to post a solution in your favorite scripting language.

PS: Maybe a better way to do this would be to generalize repeat to take both the number of times to repeat (with -1 meaning infinity) and the number of seconds to sleep between repeats. The above examples would then become:

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

Question 2

Why not: repeat [-t time] [-n number] command [args...]?

Question 3

Cool. Unfortunately both on my Ubuntu and my AIX repeat is command not found. Can you do a type repeat and let me know where's coming from?

Question 4

I'm also on Ubuntu and don't have repeat installed. Any information on how to install this would be helpful.

Question 5

repeat is a builtin command in csh and tcsh.

Question 6

@KeithThompson, csh, tcsh and zsh. Though it's more a keyword than a builtin

Question 7

Try the watch command.

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

So that:

watch -n1 command

will run the command every second (well, technically, every one second plus the time it takes for command to run as watch (at least the procps and busybox implementations) just sleeps one second in between two runs of command), forever.

Would you want to pass the command to exec instead of sh -c, use -x option:

watch -n1 -x command

On macOS, you can get watch from Mac Ports:

port install watch

Or you can get it from Homebrew:

brew install watch

Question 8

you can use MacPorts to install it. sudo port install watch

Question 9

Also available in homebrew (brew install watch).

Question 10

+1 For a new powerful tool. I used to while true; do X; sleep Y; done - This is way better.

Question 11

Problem with this tool (on Ubuntu at least) is that it forces fullscreen, so if I'm dumping some periodic info, I lose the previous info.

Question 12

It is called cmdwatch on FreeBSD (from the ports: sysutils/cmdwatch).

Question 13

Bash

while + sleep:

while true
do 
 echo "Hi"
 sleep 1
done

Here's the same thing as a shorthand one-liner (From the comments below):

while sleep 1; do echo "Hi"; done

Uses ; to separate commands and uses sleep 1 for the while test since it always returns true. You can put more commands in the loop - just separate them with ;

Question 14

I believe it works as written in a generic Bourne shell, as well.

Question 15

@dreeves, using ";" as separator, commands can be execeted in a single line. Look at Toony's answer as a example

Question 16

sleep 1 always returns true so you can use it as the while condition. Not the most readable thing in the world but absolutely legit: while sleep 1; do echo "Hi"; done

Question 17

@David Costa: You made a reasonable point, but sleep doesn’t always return true. Ī̲ used such loops (albeit with longer delay) namely because there is a way to terminate it gracefully with killing the sleep process.

Question 18

@IncnisMrsi I didn't think of it, it actually returns zero only when the time has passed and non-zero when it is terminated by a signal. Thanks for pointing it out

Question 19

This is just a shorter version of other while+sleep answers, if you are running this kind of tasks often as your daily routine, using this saves you from unnecessary key presses, and if your command line starts to get longer understanding this one is a bit easier. But this one starts with sleeping first.

This is generally useful if you need to follow something has one-line output like machine load:

while sleep 1; do uptime; done

Question 20

Yes. This should be documented next to UUOC.

Question 21

And if you want it to operate like "watch" you can do while clear; do date; command;sleep 5; done

Question 22

Wow, thanks for while sleep combination, saves keystokes!

Question 23

while sleep ... is a good solution if you want colored output. watch does not provide colored output by default (I'm sure there is some way to get it, but this answer is fast and easy.)

Question 24

Newer versions of watch support --color.

Question 25

One problem that all the answers posted so far have is that the time the command is executed can drift. For example, if you do a sleep 10 between commands, and the command takes 2 seconds to run, then it's going to run every 12 seconds; if it takes a variable amount of time to run, then over the long term the time when it runs can be unpredictable.

This might be just what you want; if so, use one of the other solutions, or use this one but simplify the sleep call.

For one-minute resolution, cron jobs will run at the specified time, regardless of how long each command takes. (In fact a new cron job will launch even if the previous one is still running.)

Here's a simple Perl script that sleeps until the next interval, so for example with an interval of 10 seconds the command might run at 12:34:00, 12:34:10, 12:34:20, etc., even if the command itself takes several seconds. If the command runs more than interval seconds, the next interval will be skipped (unlike cron). The interval is computed relative to the epoch, so an interval of 86400 seconds (1 day) will run at midnight 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?)
}

Question 26

Recent bash>= 4.2 under recent Linux kernel, based answer.

In order to limit execution time, there is no forks! Only built-in are used.

For this, I use read builtin function instead of sleep. Unfortunely this won't work with notty sessions.

Quick bash function "`repeat`" as requested:

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
}

Little test with quoted strings:

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

Depending on granularity and duration of submitted command...

Under recent Linux kernels, there is a procfile /proc/timer_list containing time information in nanoseconds.

If you want to run a command exactly once by second, your command has to end in less than a second! And from there, you have to sleep only the rest of current second.

If the delay is more important and your command doesn't require significant time, you could:

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

But if your goal is to obtain finer granularity, you have to:

Use nanoseconds information to wait until begin of a second...

For this, I wrote a little bash function:

# 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
}

After sourcing them, you could:

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

run ${command[@]} directly on command line, than compare to

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

this must give exactly same result.

Hires bash function "`repeat`" as requested:

You could source this:

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
}

Then try it:

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

Question 39

read -t is a built-in, while sleep is not. This could have border effect (ie hitting [key:return] interrupt quietly the sleep), but this could be treated by testing $foo

Question 40

If your intention is not to display a message to your screen, and if you could afford to repeat the job in terms of minutes, crontab, perhaps, would be your best tool. For example, if you wish to execute your command every minute, you would write something like this in your crontab file:

* * * * * my_precious_command

Please check out the tutorial for further example. Also, you can set the timings easily using Crontab Code Generator.

Question 41

Bash and some of its kindred shells have the convenient (( ... )) notation wherein arithmetic expressions can be evaluated.

So as an answer to your third challenge, where both the repeat count and delay between each repeat should be configurable, here's one way to do it:

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

This answer also suffers from the timing drift covered in Keith's answer.

Question 42

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); 
}

Question 43

What if we had both ?

Here's the idea : with only "interval", it repeats forever. With "interval" and "times", it repeats this number of times, separated by "interval".

The usage :

$ loop [interval [times]] command

So, the algorithm will be :

List item
if 1ドル contains only digits, it is the interval (default 2)
if 2ドル contains only digits, it is the number of times (default infinite)
while loop with these parameters
- sleep "interval"
- if a number of times has been given, decrement a var until it is reached

Therefore :

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
}

Question 44

Note: it does not work with floats, despite sleep does accept them.

Question 45

Try this out (Bash):

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

Question 46

I'm not to hot at shell, so improvements welcome. And I don't seem to have a "repeat" command in my distro.

Question 47

repeat is specific to csh and tcsh.

Question 48

@KeithThompson: and zsh

Question 49

As mentioned by gbrandt, if the watch command is available, definitely use it. Some Unix systems, however, don't have it installed by default (at least they don't where I work).

Here's another solution with slightly different syntax and output (works in BASH and SH):

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

Edit: I removed some "." in the last echo statement...holdover from my Perl days ;)

Question 50

while [ 1 ] only works because 1 is treated as a string, just like while [ -n 1 ]. while [ 0 ] or while [ jeff ] would do the same thing. while true makes much more sense.

Question 51

You can obtain the power from python interpreter from shell.

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

replace five in any time(sec) you like.

Attention: the return use SHIFT+ENTER to return input in shell. And do not forget to type 4 SPACE indent in each line in while loop.

Question 52

Note that python's os.system() executes a shell to interpret the command line, so invoking python to run shells in a loop to run a command periodically is a bit overkill. You might as well do everything in the shell.

Question 53

I agree with you. However, there is a 5 second sleep as you described in each loop. Thus the extra cost from starting a new shell can be ignored. If this cost make the period longer than expectation, you can reduce some sleep time as requirement.

Question 54

I wound up up creating a variant on swalog's answer. With his you had to wait X seconds for the first iteration, I'm also running my in the foreground so..

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

Question 55

What do the parens around ./foo.sh do? And why the additional ./foo.sh in the front?

Question 56

Quick, dirty and probably dangerous to boot, but if you're adventurous and know what you're doing, put this into repeat.sh and chmod 755 it,

while true
do 
 eval 1ドル 
 sleep 2ドル 
done

Invoke it with ./repeat.sh <command> <interval>

My spidey sense says this is probably an evil way of doing this, is my spidey sense right?

Question 57

Eval!? What for? sleep 1ドル; shift; "$@" or similar would be much better.

Question 58

Dunno why this is -2. eval may be overkill... except when you need it. Eval lets you get things like redirection onto the command line.

Question 59

You could run a script from init (adding a line to /etc/inittab). This script must run your command, sleep for the time you want to wait until run the script again, and exit it. Init will start your script again after exit.

Question 60

To repeatedly run a command in a console window I usually run something like this:

while true; do (run command here); done

This works for multiple commands as well, for example, to display a continually updating clock in a console window:

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

Question 61

Why the downvote? You can see this is a working solution by copy and pasting the example into a terminal window.

Question 62

I think you got down voted because it is a little bit dangerous and consumes the CPU.

Question 63

#! /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.1ドルsec"
 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

Question 64

Easy way to repeat a job from crontab with an interval less than one minute (20 seconds example) :

crontab: * * * * * script.sh

script.sh:

#!/bin/bash
>>type your commands here.
sleep 20
>>retype your commands here.
sleep 20
>>retype your commands here.

Gregor Brandt Gregor Brandt 8,1971 gold badge13 silver badges4 bronze badges · Accepted Answer · 2009-02-17 00:22:21Z

830

Try the watch command.

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

So that:

watch -n1 command

will run the command every second (well, technically, every one second plus the time it takes for command to run as watch (at least the procps and busybox implementations) just sleeps one second in between two runs of command), forever.

Would you want to pass the command to exec instead of sh -c, use -x option:

watch -n1 -x command

On macOS, you can get watch from Mac Ports:

port install watch

Or you can get it from Homebrew:

brew install watch

Share

Improve this answer

edited Dec 7, 2017 at 19:23

Matt's user avatar

Matt

5912 gold badges6 silver badges13 bronze badges

answered Feb 17, 2009 at 0:22

Gregor Brandt's user avatar

Gregor Brandt Gregor Brandt

8,1971 gold badge13 silver badges4 bronze badges

16

3

you can use MacPorts to install it. sudo port install watch

pope
– pope

2009年02月17日 00:27:17 +00:00
Commented Feb 17, 2009 at 0:27
12

Also available in homebrew (brew install watch).

Lyle
– Lyle

2011年05月12日 21:45:47 +00:00
Commented May 12, 2011 at 21:45
46

+1 For a new powerful tool. I used to while true; do X; sleep Y; done - This is way better.

Adam Matan
– Adam Matan

2011年05月16日 11:14:16 +00:00
Commented May 16, 2011 at 11:14
14

Problem with this tool (on Ubuntu at least) is that it forces fullscreen, so if I'm dumping some periodic info, I lose the previous info.

scorpiodawg
– scorpiodawg

2012年10月12日 01:00:22 +00:00
Commented Oct 12, 2012 at 1:00
5

It is called cmdwatch on FreeBSD (from the ports: sysutils/cmdwatch).

Ouki
– Ouki

2014年03月25日 21:29:49 +00:00
Commented Mar 25, 2014 at 21:29

| Show 11 more comments

Stack Exchange Network

Repeat a Unix command every x seconds forever

24 Answers 24

Recent bash>= 4.2 under recent Linux kernel, based answer.

Quick bash function "`repeat`" as requested:

Depending on granularity and duration of submitted command...

Use nanoseconds information to wait until begin of a second...

Hires bash function "`repeat`" as requested:

Perl

You must log in to answer this question.

Linked

Hot Network Questions

Repeat a Unix command every x seconds forever

24 Answers 24

Recent bash>= 4.2 under recent Linux kernel, based answer.

Quick bash function "repeat" as requested:

Depending on granularity and duration of submitted command...

Use nanoseconds information to wait until begin of a second...

Hires bash function "repeat" as requested:

Perl

You must log in to answer this question.

Linked

Related

Hot Network Questions

Quick bash function "`repeat`" as requested:

Hires bash function "`repeat`" as requested: