每30秒运行一次cron

你在分钟说明符中有*/30 -这意味着每分钟，但步长为30(换句话说，每半小时)。由于cron不能精确到次分钟分辨率，你需要找到另一种方法。

一种可能，尽管它有点拼凑__abc0，是有两个工作，一个抵消30秒:

# Need these to run on 30-sec boundaries, keep commands in sync.
* * * * *              /path/to/executable param1 param2
* * * * * ( sleep 30 ; /path/to/executable param1 param2 )

您将看到我添加了注释并进行了格式化，以确保它们易于保持同步。

这两个cron作业实际上每分钟运行一次，但后者作业将在执行“肉”之前等待半分钟。的工作，/path/to/executable。

对于其他(非基于- __abc0的)选项，请参阅这里的其他答案，特别是提到fcron和systemd的答案。假设你的系统有能力使用它们(比如安装fcron或有一个包含systemd的发行版)，这些可能是更可取的。

如果你不想要使用这个笨拙的解决方案，你可以使用一个基于循环的解决方案，只是做了一个小的修改。你仍然需要管理保持你的进程以某种形式运行，但是，一旦排序，下面的脚本应该工作:

#!/bin/env bash


# Debug code to start on minute boundary and to
# gradually increase maximum payload duration to
# see what happens when the payload exceeds 30 seconds.


((maxtime = 20))
while [[ "$(date +%S)" != "00" ]]; do true; done


while true; do
# Start a background timer BEFORE the payload runs.


sleep 30 &


# Execute the payload, some random duration up to the limit.
# Extra blank line if excess payload.


((delay = RANDOM % maxtime + 1))
((maxtime += 1))
echo "$(date) Sleeping for ${delay} seconds (max ${maxtime})."
[[ ${delay} -gt 30 ]] && echo
sleep ${delay}


# Wait for timer to finish before next cycle.


wait
done

诀窍是使用sleep 30，但在有效负载运行之前在背景中启动它。然后，在有效负载完成后，只需等待后台sleep完成。

如果有效载荷需要n秒(其中n <= 30)，则有效载荷之后的等待将是30 - n秒。如果它花了更多的超过30秒，那么下一个循环将被延迟，直到有效载荷完成，但不会更久。

您将看到其中的调试代码以一分钟为边界开始，以使输出最初更容易遵循。我还逐渐增加最大有效负载时间，因此您最终会看到有效负载超过30秒的周期时间(输出额外的空行，因此效果很明显)。

下面是一个示例运行(其中周期通常在前一个周期后30秒开始):

Tue May 26 20:56:00 AWST 2020 Sleeping for 9 seconds (max 21).
Tue May 26 20:56:30 AWST 2020 Sleeping for 19 seconds (max 22).
Tue May 26 20:57:00 AWST 2020 Sleeping for 9 seconds (max 23).
Tue May 26 20:57:30 AWST 2020 Sleeping for 7 seconds (max 24).
Tue May 26 20:58:00 AWST 2020 Sleeping for 2 seconds (max 25).
Tue May 26 20:58:30 AWST 2020 Sleeping for 8 seconds (max 26).
Tue May 26 20:59:00 AWST 2020 Sleeping for 20 seconds (max 27).
Tue May 26 20:59:30 AWST 2020 Sleeping for 25 seconds (max 28).
Tue May 26 21:00:00 AWST 2020 Sleeping for 5 seconds (max 29).
Tue May 26 21:00:30 AWST 2020 Sleeping for 6 seconds (max 30).
Tue May 26 21:01:00 AWST 2020 Sleeping for 27 seconds (max 31).
Tue May 26 21:01:30 AWST 2020 Sleeping for 25 seconds (max 32).
Tue May 26 21:02:00 AWST 2020 Sleeping for 15 seconds (max 33).
Tue May 26 21:02:30 AWST 2020 Sleeping for 10 seconds (max 34).
Tue May 26 21:03:00 AWST 2020 Sleeping for 5 seconds (max 35).
Tue May 26 21:03:30 AWST 2020 Sleeping for 35 seconds (max 36).


Tue May 26 21:04:05 AWST 2020 Sleeping for 2 seconds (max 37).
Tue May 26 21:04:35 AWST 2020 Sleeping for 20 seconds (max 38).
Tue May 26 21:05:05 AWST 2020 Sleeping for 22 seconds (max 39).
Tue May 26 21:05:35 AWST 2020 Sleeping for 18 seconds (max 40).
Tue May 26 21:06:05 AWST 2020 Sleeping for 33 seconds (max 41).


Tue May 26 21:06:38 AWST 2020 Sleeping for 31 seconds (max 42).


Tue May 26 21:07:09 AWST 2020 Sleeping for 6 seconds (max 43).

如果您想避免这种笨拙的解决方案，这可能更好。你仍然需要一个cron作业(或等效的)来定期检测这个脚本是否正在运行，如果没有，就启动它。但是脚本本身会处理计时。

我的一些同事会说kludges是我的专长:-)

你不能。Cron的粒度为60秒。

* * * * * cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\''
* * * * * sleep 30 && cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\''

Cron的粒度以分钟为单位，而并不是被设计为每x秒唤醒一次以运行某项操作。在循环中运行你的重复任务，它应该做你需要的:

#!/bin/env bash
while [ true ]; do
sleep 30
# do what you need to here
done

你可以看看我对类似的问题的回答

基本上，我在这里包含了一个名为“runEvery.sh”的bash脚本，您可以用cron每1分钟运行一次该脚本，并将希望运行的实际命令和希望运行该命令的频率(以秒为单位)作为参数传递。

就像这样

* * * * * ~/bin/runEvery.sh 5 myScript.sh

Cron作业不能用于以秒为间隔调度作业。例如，你不能安排一个cron作业每5秒运行一次。另一种方法是编写一个shell脚本，在其中使用sleep 5命令。

使用bash while循环每5秒创建一个shell脚本。sh，如下所示。

$ cat every-5-seconds.sh
#!/bin/bash
while true
do
/home/ramesh/backup.sh
sleep 5
done

现在，在后台使用nohup执行这个shell脚本，如下所示。这将在退出会话后继续执行脚本。这将每5秒执行一次backup.sh shell脚本。

$ nohup ./every-5-seconds.sh &

使用fcron (http://fcron.free.fr/) -以秒为单位提供粒度，比cron (vixie-cron)更好，功能更丰富，也更稳定。我曾经做过一些愚蠢的事情，比如在一台机器上运行60个php脚本，设置非常愚蠢，但它仍然发挥了作用!

不需要两个cron条目，你可以把它放在一个:

* * * * * /bin/bash -l -c "/path/to/executable; sleep 30 ; /path/to/executable"

在你的例子中:

* * * * * /bin/bash -l -c "cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\'' ; sleep 30 ; cd /srv/last_song/releases/20120308133159 && script/rails runner -e production '\''Song.insert_latest'\''"

Crontab job可用于以分钟/小时/天为单位调度作业，但不能以秒为单位。替代方案:

创建一个脚本，每30秒执行一次:

#!/bin/bash
# 30sec.sh


for COUNT in `seq 29` ; do
cp /application/tmp/* /home/test
sleep 30
done

使用crontab -e和crontab来执行这个脚本:

* * * * * /home/test/30sec.sh > /dev/null

使用注意:

$ watch --interval .30 script_to_run_every_30_sec.sh

我刚刚有一个类似的任务要做，并使用了以下方法:

nohup watch -n30 "kill -3 NODE_PID" &

我需要在几个小时内每30秒执行一次定期kill -3(以获得程序的堆栈跟踪)。

nohup ... &

这是在这里确保我不会失去手表的执行，如果我松散的外壳(网络问题，windows崩溃等…)

在dir /etc/cron.d/

新建一个文件excute_per_30s

* * * * * yourusername  /bin/date >> /home/yourusername/temp/date.txt
* * * * * yourusername sleep 30; /bin/date >> /home/yourusername/temp/date.txt

是否每30秒运行一次cron

谢谢你的回答。简单来说，我喜欢混合的解决方案，crontab上的控件和脚本上的时间划分。这就是我所做的每20秒运行一个脚本(每分钟3次)。Crontab行:

 * * * * 1-6 ./a/b/checkAgendaScript >> /home/a/b/cronlogs/checkAgenda.log

脚本:

cd /home/a/b/checkAgenda


java -jar checkAgenda.jar
sleep 20
java -jar checkAgenda.jar
sleep 20
java -jar checkAgenda.jar

在shell循环中运行，示例:

#!/bin/sh
counter=1
while true ; do
echo $counter
counter=$((counter+1))
if [[ "$counter" -eq 60 ]]; then
counter=0
fi
wget -q http://localhost/tool/heartbeat/ -O - > /dev/null 2>&1 &
sleep 1
done

写一个shell脚本 创建

纳米every30second.sh

并编写脚本

#!/bin/bash
For  (( i=1; i <= 2; i++ ))
do
write Command here
sleep 30
done

然后为这个脚本设置cron crontab - e < / >强