28

Are there any substitutes, alternatives or bash tricks for delaying commands without using sleep? For example, performing the below command without actually using sleep:

$ sleep 10 && echo "This is a test"
Fabby
  • 5,836
  • 2
  • 22
  • 38
user321697
  • 309
  • 1
  • 3
  • 4
  • 43
    What's wrong with `sleep`? – muru Nov 19 '18 at 10:55
  • 5
    There's no real reason other than curiosity. I thought it would be interesting to learn some alternative solutions. I think `at` might be one, but I couldn't find any usage examples. – user321697 Nov 19 '18 at 11:11
  • What do you want to wait for? If there’s an event you’re waiting for, you’d typically use a while loop, testing for the condition and sleeping for one second (or whatever makes sense). If you’re waiting for a child process to finish, then you can use the wait builtin. If it’s something else, do elaborate, please. – Grega Bremec Nov 19 '18 at 11:12
  • 1
    @user321697 “at” is to schedule single jobs. they are executed by the atd service, so they won’t pause your shell script. one use case for at would be to have it do something at a specified time (async) and create a marker file when it’s finished, while your script is waiting for that file to appear in a while loop. you could achieve a similar effect by scheduling a job to send your script a SIGCONT and then freezing your script by sending yourself a SIGSTOP. – Grega Bremec Nov 19 '18 at 11:13
  • https://askubuntu.com/a/339301/158442 https://stackoverflow.com/questions/18945669/how-to-run-a-script-at-a-certain-time-on-linux – muru Nov 19 '18 at 11:24
  • Related: https://unix.stackexchange.com/q/68236/117549 – Jeff Schaller Nov 19 '18 at 14:31
  • 1
    I came here expecting everyone to suggest a spinlock. I'm pleasantly surprised by all the answers. – Daan van Hoek Nov 19 '18 at 15:59
  • @DaanvanHoek: you mean a spin-wait on `$(date)` or something? Yeah, that would be a horrible option. I don't think a spin*lock* would help you, though: you'd need to figure out when to unlock it from another thread/process. I don't think spin-waiting for a given time would fit the definition of a lock: waiting for a resource to become available. (e.g. https://en.wikipedia.org/wiki/Spinlock) I don't think we can really count time as a resource that you can manage exclusive access to. But yes, definitely some interesting answers. – Peter Cordes Nov 19 '18 at 22:36
  • 5
    Re: "Curiosity" -- in https://unix.stackexchange.com/help/dont-ask, note the requirement that *"You should only ask practical, answerable questions **based on actual problems that you face.**"* -- that this has been well-received despite controvening that guideline makes it a rather rare exception. – Charles Duffy Nov 21 '18 at 01:02
  • 1
    @CharlesDuffy the votes on this question most likely correlate with a visit from the HNQ; I agree that it's not a useful question in the current state. – Jeff Schaller Nov 25 '18 at 14:56
  • @muru, you can't kill a sleeping process. Even using `kill -9`. – James Bond Jan 22 '22 at 17:37
  • @JamesBond I think you might be confusing run-of-the-mill sleeping processes with processes in *uninterruptible* sleep. – muru Jan 22 '22 at 17:45
  • @muro Sleep is often used as a hacky replacement for some other thing to complete. The problem is that this can take more time than needed or if that process that is being depended on goes longer than the sleep accounts for it'll break anyway. Generally, I avoid sleep and try to find a solution that tracks the dependency more accurately. In other words, instead of what's wrong with sleep, can I avoid sleep. – flickerfly Jul 20 '23 at 17:31

10 Answers10

34

With bash builtins, you can do:

coproc read -t 10 && wait "$!" || true

To sleep for 10 seconds without using sleep. The coproc is to make so that read's stdin is a pipe where nothing will ever come out from. || true is because wait's exit status will reflect a SIGALRM delivery which would cause the shell to exit if the errexit option is set.

In other shells:

mksh and ksh93 have sleep built-in, no point in using anything else there (though they both also support read -t).

zsh also supports read -t, but also has a builtin wrapper around select(), so you can also use:

zmodload zsh/zselect
zselect -t 1000 # centiseconds

If what you want is schedule things to be run from an interactive shell session, see also the zsh/sched module in zsh.

Stéphane Chazelas
  • 522,931
  • 91
  • 1,010
  • 1,501
  • 2
    Would you consider `read -t 10 < /dev/zero || true` ? – Jeff Schaller Nov 19 '18 at 14:22
  • 6
    @JeffSchaller I would avoid it as that's a busy loop. – Stéphane Chazelas Nov 19 '18 at 14:23
  • @StéphaneChazelas I wouldn't expect that to be a busy loop – I'd expect any shell's `read` to be implemented using select(2) or something similar (implying that read-with-timeout would be a good answer to this question). I'm expressing surprise rather than contradicting you, but can you point to further discussion of this? – Norman Gray Nov 19 '18 at 15:41
  • 6
    @NormanGray, `/dev/zero` is a file that contains an infinite amount of data (NUL bytes). So `read` will read as much as it can during those 10 seconds. Thankfully, in the case of `bash` which doesn't support storing NUL bytes in its variables, that won't use up any memory, but that will still hog CPU resources. – Stéphane Chazelas Nov 19 '18 at 15:44
  • 1
    @StéphaneChazelas Ach, I'm an idiot! I was looking at the `read -t` and not at the `/dev/zero`. My first thought on seeing this question was 'read from a pipe to which nothing is written, or some other input which will never produce bytes, and time out,' and @JeffSchaller's answer looked like he'd had the same thought. It occurs to me that `read -t 10 – Norman Gray Nov 19 '18 at 15:57
  • 2
    @NormanGray, if run from a terminal, `/dev/stdout` would be the tty device, so it would have side effects (like stopping the script if run in background) and would return if the user presses enter for instance. [`read -t 10 /dev/stdout | :`](/a/222609) would work on Linux, but on Linux only, while `coproc` should work regardless of the OS. – Stéphane Chazelas Nov 19 '18 at 16:10
19

You have alternatives to sleep: They are at and cron. Contrary to sleep these need you to provide the time at which you need them to run.

  • Make sure the atd service is running by executing service atd status.
    Now let's say the date is 11:17 am UTC; if you need to execute a command at 11:25 UTC, the syntax is: echo "This is a test" | at 11:25.
    Now keep in mind that atd by default will not be logging the completion of the jobs. For more refer this link. It's better that your application has its own logging.

  • You can schedule jobs in cron, for more refer : man cron to see its options or crontab -e to add new jobs. /var/log/cron can be checked for the info on execution on jobs.

FYI sleep system call suspends the current execution and schedules it w.r.t. the argument passed to it.

EDIT:

As @Gaius mentioned , you can also add minutes time to at command.But lets say time is 12:30:30 and now you ran the scheduler with now +1 minutes. Even though 1 minute, which translates to 60 seconds was specified , the at doesn't really wait till 12:31:30 to execute the job, rather it executes the job at 12:31:00. The time-units can be minutes, hours, days, or weeks. For more refer man at

e.g: echo "ls" | at now +1 minutes

ss_iwe
  • 1,136
  • 6
  • 12
  • 7
    This is not true, you can schedule an at job for say now +1 minute, to run in a minutes time – Gaius Nov 19 '18 at 16:48
11

Some other ideas.

top -d10 -n2 >/dev/null

vmstat 10 2 >/dev/null

sar 10 1 >/dev/null

timeout 10s tail -f /dev/null
steve
  • 21,582
  • 5
  • 48
  • 75
7

Since there are answers which are suggesting to use the non-standard -t delay option of read, here is a way to do a timed-out read in a standard shell:

{ ss=`stty -g`; stty -icanon min 0 time 20; read foo; stty "$ss"; }

The argument to stty time is in tenths of second.

5

Back in the days of microcomputers running BASIC, delays were usually accomplished with an empty loop:

FOR I = 1 TO 10000:NEXT

The same principle could be used to insert a delay in a shell script:

COUNTER=0; while [ $COUNTER -lt 10000 ]; do :; let COUNTER=COUNTER+1; done

Of course, the problem with this approach is that the length of the delay will vary from machine to machine according to its processor speed (or even on the same machine under different loads). Unlike sleep, it will probably also max out your CPU (or one of its cores).

Psychonaut
  • 864
  • 8
  • 17
  • 2
    A good way to make heat. – ctrl-alt-delor Nov 19 '18 at 14:50
  • 2
    Delay-loops are a terrible idea for anything except the very shortest of sleeps (a couple nanoseconds or clock cycles in a device driver) on any modern CPU that can run a Unix-like OS. i.e. a sleep so short you can't usefully have the CPU do anything else while waiting, like schedule another process or enter a low-power sleep state before waking on a timer interrupt. Dynamic CPU-frequency makes it impossible to even calibrate a delay loop for counts per second, except as a minimum delay potentially sleeping a lot longer at low clock speeds before ramping up. – Peter Cordes Nov 19 '18 at 22:43
  • Ancient computers had a power consumption that was much less dependent on workload. Modern CPUs need to dynamically power down different parts of the chip as much as possible to not melt (e.g. power down parts of the FPU or SIMD execution units while only integer code is running, or at least gate the clock signal to parts of the chip that don't need to be switching). And entering a low-power sleep state when idle (instead of spinning in an infinite loop waiting for timer interrupts) is also more recent than the ancient computers you mention. – Peter Cordes Nov 19 '18 at 22:46
  • For more about CPU history, see Modern Microprocessors A 90-Minute Guide! - http://www.lighterra.com/papers/modernmicroprocessors/. – Peter Cordes Nov 19 '18 at 22:47
5

Using the bash built-in variable $SECONDS and a busy-loop:

for((target=$((SECONDS + 10)); SECONDS < target; true)); do :; done
Jeff Schaller
  • 66,199
  • 35
  • 114
  • 250
4

the oldest trick in the book:

read && echo "This is a test"

Just hit Enter and it'll continue!

Fabby
  • 5,836
  • 2
  • 22
  • 38
  • This wont if the process needs to be run interaction free or in the background right? – ss_iwe Nov 19 '18 at 11:30
  • Correct: But that was not one of the OP's requirements as per the original question, so still a valid answer... **;-) >:-)** – Fabby Nov 20 '18 at 11:30
  • 2
    OP specifically gives an example (with `sleep`) and asks for an equivalent alternative without. So `read` doesn't parse, sorry. ;) – AnoE Nov 20 '18 at 12:58
  • @AnoE Stéphane's answer is of course the best, mine is just the oldest `--- press «enter» to continue ---` ;-) – Fabby Nov 20 '18 at 18:00
3

There is no built-in, that does the same as sleep (unless sleep is built-in). However there are some other commands that will wait.

A few include.

  • at and cron: used to schedule tasks at a specific time.

  • inotifywait: used to wait for a file, or files to be modified/removed/added/etc

Fabby
  • 5,836
  • 2
  • 22
  • 38
ctrl-alt-delor
  • 27,473
  • 9
  • 58
  • 102
  • Thanks for this. Could you provide an example for performing a scheduled task (10 seconds from now) with `at`? – user321697 Nov 19 '18 at 11:23
  • 1
    an edit *and an upvote!* **;-)** – Fabby Nov 19 '18 at 11:23
  • `cron` store tasks in `crontab`, right? Where does `at` store the scheduled data? – user321697 Nov 19 '18 at 11:25
  • @user321697 Already answered [here](https://serverfault.com/questions/174678/how-do-i-print-contents-of-at-jobs) – Fabby Nov 19 '18 at 11:26
  • Sorry for reverting back your edit to the Q: you changed the OPs question's main purpose which would invalidate the simplest answer of all... **¯\\_(ツ)_/¯** – Fabby Nov 19 '18 at 11:38
  • @user321697 `at(1)` resolution is in minutes, so you could do `echo 'date > /tmp/timestamp.txt' | at now + 1 min`. Internally it usually stores it in `/var/spool/cron/atjobs`, but you should `atq` to see scheduled jobs. – Matija Nalis Nov 19 '18 at 21:38
3

A classic from the Land of Windows and Batches:

ping -c 11 localhost >/dev/null && echo "This is a test"
Joker_vD
  • 131
  • 2
0

If you want to interactively wait for a new line in a file, then 

tail -f
.

Waiting for a change on a filesystem? Then use e.g. 

inotify / inoticoming
.

And there are other options, depending on what you mean with "wait".

Edheldil
  • 1,145
  • 6
  • 5