How to make Crontab execute a task every second

Crontab is a scheduled scheduling configuration file under Linux. Through it, we can make system programs, scripts, commands, and tasks run at set times. , interval and cycle operation. The smallest time granularity in Crontab is minutes. In other words, through Crontab configuration, we can execute the target task at most once per minute. More frequent execution is not possible and we can only use other methods.

Related learning recommendations: linux video tutorial

For example, what should you do if you want a program to be executed every 30 seconds?

There are still ways to work around it. One idea is to add two configurations in Crontab, one is for normal scheduling and is executed once every minute, and the other is to wait for 30 seconds before executing.

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

This method feels a bit stiff and weird, but it does work. This method can actually be abbreviated into one line:

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

Another method is to use the watch command:

$ watch --interval .30 script_to_run_every_30_sec.sh

But watch is a command line tool, we can use nohup command lets it run in the background.

SystemD timer

If the Linux system we use has SystemD, we can use the SystemD timer to schedule programs at any time granularity, which can theoretically be as small as the nanosecond level - of course, It's kind of crazy to do that. In short, its flexibility in task scheduling is much higher than Cron - there is no need to use such a crappy solution as sleep.

Compared with crontab that completes the configuration in one line, establishing a SystemD timer is slightly more complicated, but in order to better implement scheduling tasks with a granularity smaller than 'per minute', this method is worth trying.

The implementation principle of SystemD timer is simply two parts: a system service and a SystemD timer. SystemD timer performs scheduling, and tasks are written in service.

Here is a simple example. The goal is to have the system logger output "Hello World" every ten seconds;

/etc/systemd/system/helloworld.service

[Unit]
Description=Say Hello
[Service]
ExecStart=/usr/bin/logger -i Hello World

/etc/systemd/system/helloworld.timer

[Unit]
Description=Say Hello every 10 seconds
[Timer]
OnBootSec=10
OnUnitActiveSec=10
AccuracySec=1ms
[Install]
WantedBy=timers.targethelloworld.timer里并没有声明service的名称，那它和service是如何关联的呢？没错，因为它们的名称相同，都是helloworld。

If you want the entire system to use this timer, these two files need to be placed in/etc/systemd/system. If you want to use it for a certain user, place it in ~/.config/systemd/user. If you want this timer to run immediately, you need to execute the following command: The

–now

tag in

systemctl enable --now helloworld.timer

causes the timer to execute immediately. Otherwise, the operation will only be triggered after the system is restarted or the user logs in.

[Timer]The functions of each field in the section are as follows:

• OnBootSec – How many seconds after the system starts to start scheduling
• OnUnitActiveSec – The time interval for repeatedly scheduling related services. It is this line of configuration that determines the scheduled actions like cron job.
• AccuracySec – Timer accuracy. The default is one minute, very similar to cron. It can be required to be higher, but the increased precision will bring more system consumption and wake up the CPU more frequently. The above configuration says 1ms, which is obviously not a smart decision. Usually we can set it to 1 (1 second), which is enough for our timer accuracy requirements of less than 1 minute time granularity. Because of this, we will see that the output of the "Hello World" message is often delayed by about 1 second when the actual program is running. If you don't think the delay of this second or so is a problem, this is how it should be set.

You will find that SystemD timer and Crontab timer are not the same - the task scheduling period is not set according to the year, month, day, hour and minute period, it is based on our first time It starts at the time it is executed, appending one cycle of time each time. If we like the time configuration method like Crontab, SystemD timer also supports it, then we need to remove OnBootSec and OnUnitActiveSec and replace them with OnCalendar, as follows is an example:

OnCalendar=*-*-* *:*:00,10,20,30,40,50

Finally, by default, the SystemD timer and service are associated with the same name. If you like, you can also configure it in [Timer] Pair by specifying the Unit field.

The above methods can all implement scheduled scheduling tasks with sub-minute granularity. Each has its advantages. SystemD timers look more formal, but a little more complex. Crontab sleepAlthough the method is awkward, it is not incompetent for some small tasks.

The above is the detailed content of How to make Crontab execute a task every second. For more information, please follow other related articles on the PHP Chinese website!