Wie ein Unix-Skript erhalten alle 15 Sekunden zu laufen?
Frage
Ich habe ein paar Lösungen gesehen, einschließlich Uhr und einfach eine Schleife (und Schlafen) Skript im Hintergrund ausgeführt wird, aber nichts ist ideal gewesen.
Ich habe ein Skript, das alle 15 Sekunden ausgeführt werden muss, und da cron nicht Sekunden unterstützen wird, ich bin links, etwas anderes zu herauszufinden.
Was ist die robuste und effiziente Art und Weise ein Skript alle 15 Sekunden auf Unix laufen zu lassen? Das Skript muss auch nach einem Neustart ausgeführt werden.
Lösung
würde ich cron verwenden, um einen Skript jede Minute zu laufen, und das Skript Skript viermal mit einem 15-Sekunden-Schlaf zwischen den Läufen laufen lassen.
(Das setzt voraus, Ihr Skript schnell zu laufen -. Sie Schlafzeiten einstellen könnten, wenn nicht)
Auf diese Weise erhalten Sie alle Vorteile von cron
sowie Ihren 15 Sekunden Laufzeitraum.
Edit:. Siehe auch @ bmb Kommentar unterhalb
Andere Tipps
Wenn Sie darauf bestehen, von Ihrem Skript von cron ausgeführt wird:
* * * * * /foo/bar/your_script
* * * * * sleep 15; /foo/bar/your_script
* * * * * sleep 30; /foo/bar/your_script
* * * * * sleep 45; /foo/bar/your_script
und ersetzen Sie Ihre Skriptnamen und Pfad / foo / bar / your_script
modifizierte Version des oben:
mkdir /etc/cron.15sec
mkdir /etc/cron.minute
mkdir /etc/cron.5minute
in der / 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
Wird dies nicht im Hintergrund ausgeführt wird es tun?
#!/bin/sh
while [ 1 ]; do
echo "Hell yeah!" &
sleep 15
done
Das ist etwa so effizient wie es geht. Der wichtige Teil wird nur alle 15 Sekunden ausgeführt und das Skript schläft, den Rest der Zeit (also nicht Zyklen verschwenden).
Ich schrieb einen Scheduler schneller als cron. Ich habe auch einen überlappenden Wache umgesetzt. Sie können den Scheduler konfigurieren nicht neu zu starten, wenn vorherige noch läuft. Schauen Sie sich auf https://github.com/sioux1977/scheduler/wiki
Verwenden Sie nanosleep (2) . Es nutzt Struktur timespec
, die mit Nanosekunden-Präzision Zeitintervalle angeben.
struct timespec {
time_t tv_sec; /* seconds */
long tv_nsec; /* nanoseconds */
};
#! /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
Da meine vorherige Antwort, die ich mit einer anderen Lösung kam, die besser anders und vielleicht ist. Dieser Code ermöglicht Prozesse mehr als 60 Mal pro Minute mit mikrosekundengenau ausgeführt werden. Sie müssen das usleep Programm, um diese Arbeit zu machen. Sollte gut sein, um bis zu 50 Mal pro Sekunde.
#! /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
mögliche Überlappung der Ausführung zu vermeiden, die einen Verriegelungsmechanismus verwenden, wie in der Thread .