How to get a unix script to run every 15 seconds?

Question

I've seen a few solutions, including watch and simply running a looping (and sleeping) script in the background, but nothing has been ideal.

I have a script that needs to run every 15 seconds, and since cron won't support seconds, I'm left to figuring out something else.

What's the most robust and efficient way to run a script every 15 seconds on unix? The script needs to also run after a reboot.

How long does it take to run? – Adam Matan Jun 23 '09 at 18:21 — Adam Matan, Jun 23 '09 at 18:21

score 294 · Answer 1 · answered Jun 23 '09 at 18:28

294

If you insist of running your script from cron:

* * * * * /foo/bar/your_script
* * * * * sleep 15; /foo/bar/your_script
* * * * * sleep 30; /foo/bar/your_script
* * * * * sleep 45; /foo/bar/your_script

and replace your script name&path to /foo/bar/your_script

answered Jun 23 '09 at 18:28

rasjani

6,075
3
18
32

5

This worked perfectly for me. The soltion above this on using a background task was spawning several child processes and causing memory issues on my end. – Hacknightly Jun 07 '12 at 15:06
4

if running php script do this:`* * * * * sleep 15; php /foo/bar/your_script` – ImaginedDesign Mar 07 '14 at 17:15
2

if running php script you can prepend the line `#!/usr/bin/php` to the top of your php script and make it executable – Aaron Blenkush Sep 08 '14 at 18:23
19

I feel embarrassed that I had to google for this solution. Maybe stackoverflow makes me think less. – chris finne Oct 17 '14 at 16:10
1

In response to @Hacknightly, it only happens when the scripts exceed runtime of 15 seconds and/or tasks are not able to release enough memory that can be used by the system – Abel Callejo Dec 20 '18 at 06:55

RichieHindle · Accepted Answer · 2011-09-19T08:32:06.570

78

I would use cron to run a script every minute, and make that script run your script four times with a 15-second sleep between runs.

(That assumes your script is quick to run - you could adjust the sleep times if not.)

That way, you get all the benefits of cron as well as your 15 second run period.

Edit: See also @bmb's comment below.

edited Sep 19 '11 at 08:32

answered Jun 23 '09 at 18:19

RichieHindle

244,085
44
340
385

@Aiden: Ha! My nemesis, we meet again! – RichieHindle Jun 23 '09 at 18:21
56

If the script is not consistent in how long it takes to run, make four copies of the script. One sleeps 15 seconds before starting, another 30, another 45, and another zero. Then run all four every minute. – bmb Jun 23 '09 at 18:23
@RichieHindle - Have no fear, I got assassinated for not granulating the minutes into seconds. But i'm watching you :P – Aiden Bell Jun 23 '09 at 18:23
How can this be cron is triggered every 1 minute – DevZer0 Jun 25 '13 at 07:11
Actually the outter-script should run the inner script three times, not four. Otherwise the last run of the last minute will overlap the frist run of the next minute. That would be running the inner script 5 times every minute instead of four. – Tulains Córdova Mar 04 '15 at 15:14
@user1598390: No. With 15-second sleeps, the four runs will be at zero seconds, 15 seconds, 30 seconds and 45 seconds. Four runs, three sleeps between. – RichieHindle Mar 04 '15 at 16:47
to add to @bmb suggestion, i use `sleep 15;[command]` then `sleep 30;[command]` then `sleep 45;[command]` – trrrrrrm Jun 14 '16 at 04:43

Marc Perkel · Answer 3 · 2013-10-23T14:58:05.027

Modified version of the above:

mkdir /etc/cron.15sec
mkdir /etc/cron.minute
mkdir /etc/cron.5minute

add to /etc/crontab:

* * * * * root run-parts /etc/cron.15sec > /dev/null 2> /dev/null
* * * * * root sleep 15; run-parts /etc/cron.15sec > /dev/null 2> /dev/null
* * * * * root sleep 30; run-parts /etc/cron.15sec > /dev/null 2> /dev/null
* * * * * root sleep 45; run-parts /etc/cron.15sec > /dev/null 2> /dev/null

* * * * * root run-parts /etc/cron.minute > /dev/null 2> /dev/null
*/5 * * * * root run-parts /etc/cron.5minute > /dev/null 2> /dev/null

score 14 · Answer 4 · edited Jun 13 '17 at 07:52

14

Won't running this in the background do it?

#!/bin/sh
while [ 1 ]; do
    echo "Hell yeah!" &
    sleep 15
done

This is about as efficient as it gets. The important part only gets executed every 15 seconds and the script sleeps the rest of the time (thus not wasting cycles).

edited Jun 13 '17 at 07:52

Eric Schoonover

44,080
43
148
200

answered Jun 23 '09 at 18:28

scvalex

13,484
2
32
42

9

Edits must be at least 8 characters (which is idiotic, IMHO) so I couldn't add the `&` at the end of line 3. In any case, as is, this doesn't run every 15 seconds. This runs every "15 seconds + however long `echo hello` takes to run". Which could be 0.01 seconds; could be 19 hours. – Parthian Shot Aug 11 '15 at 17:25

score 1 · Answer 5 · answered Sep 15 '15 at 10:40

1

I wrote a scheduler faster than cron. I have also implemented an overlapping guard. You can configure the scheduler to not start new process if previous one is still running. Take a look at https://github.com/sioux1977/scheduler/wiki

answered Sep 15 '15 at 10:40

siouxes

51
2

score 0 · Answer 6 · answered Jan 15 '13 at 11:39

0

Use nanosleep(2). It uses structure timespec that is used to specify intervals of time with nanosecond precision.

struct timespec {
           time_t tv_sec;        /* seconds */
           long   tv_nsec;       /* nanoseconds */
       };

answered Jan 15 '13 at 11:39

Alexander Suraphel

8,105
7
43
80

1

I'm going to go ahead and guess they don't need nanosecond precision, since the thing they're spawning every 15 seconds is a shell script, not a kernel thread. – Parthian Shot Aug 10 '15 at 23:08
@ParthianShot maybe but you never know. – Alexander Suraphel Aug 11 '15 at 09:23

score 0 · Answer 7 · answered Jan 09 '14 at 14:36

#! /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

score 0 · Answer 8 · answered Jan 23 '14 at 15:31

Since my previous answer I came up with another solution that is different and perhaps better. This code allows processes to be run more than 60 times a minute with microsecond precision. You need the usleep program to make this work. Should be good to up to 50 times a second.

#! /bin/sh

# Microsecond Cron
# Usage: cron-ms start
# Copyright 2014 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

basedir=/etc/cron-ms

if [ $# -eq 0 ]
then
   echo
   echo "cron-ms by Marc Perkel"
   echo
   echo "This program is used to run all programs in a directory in parallel every X times per minute."
   echo "Think of this program as cron with microseconds resolution."
   echo
   echo "Usage: cron-ms start"
   echo
   echo "The scheduling is done by creating directories with the number of"
   echo "executions per minute as part of the directory name."
   echo
   echo "Examples:"
   echo "  /etc/cron-ms/7      # Executes everything in that directory  7 times a minute"
   echo "  /etc/cron-ms/30     # Executes everything in that directory 30 times a minute"
   echo "  /etc/cron-ms/600    # Executes everything in that directory 10 times a second"
   echo "  /etc/cron-ms/2400   # Executes everything in that directory 40 times a second"
   echo
   exit
fi

# If "start" is passed as a parameter then run all the loops in parallel
# The number of the directory is the number of executions per minute
# Since cron isn't accurate we need to start at top of next minute

if [ $1 = start ]
then
   for dir in $basedir/* ; do
      $0 ${dir##*/} 60000000 &
   done
   exit
fi

# Loops per minute and the next interval are passed on the command line with each loop

loops=$1
next_interval=$2

# Sleeps until a specific part of a minute with microsecond resolution. 60000000 is full minute

usleep $(( $next_interval - 10#$(date +%S%N) / 1000 ))

# Run all the programs in the directory in parallel

for program in $basedir/$loops/* ; do
   if [ -x $program ] 
   then
      $program &> /dev/null &
   fi
done

# Calculate next_interval

next_interval=$(($next_interval % 60000000 + (60000000 / $loops) ))

# If minute is not up - call self recursively

if [ $next_interval -lt $(( 60000000 / $loops * $loops)) ]
then
   . $0 $loops $next_interval &
fi

# Otherwise we're done

Edit the original one instead of posting again! – Vogon Jeltz Feb 20 '16 at 15:47 — Vogon Jeltz, Feb 20 '16 at 15:47

score -1 · Answer 9 · edited May 23 '17 at 12:10

-1

To avoid possible overlapping of execution, use a locking mechanism as described in that thread.

edited May 23 '17 at 12:10

Community

1
1

answered Jan 23 '13 at 11:20

flm

952
8
14

2

-1 The OP didn't say he needed to avoid overlapping execution; the thing could be reentrant. Plus, this doesn't answer the question. – Parthian Shot Aug 11 '15 at 17:26

How to get a unix script to run every 15 seconds?

9 Answers9

Linked