What is the purpose of delayed suspend (Ctrl-Y) in Bash?

Question

The full portion of the Bash man page which is applicable only says:

If the operating system on which bash is running supports job control, bash contains facilities to use it. Typing the suspend character (typically ^Z, Control-Z) while a process is running causes that process to be stopped and returns control to bash. Typing the delayed suspend character (typically ^Y, Control-Y) causes the process to be stopped when it attempts to read input from the terminal, and control to be returned to bash. The user may then manipulate the state of this job, using the bg command to continue it in the background, the fg command to continue it in the foreground, or the kill command to kill it. A ^Z takes effect immediately, and has the additional side effect of causing pending output and typeahead to be discarded.

I have never used Ctrl-Y; I only just learned about it. I have done fine with Ctrl-Z (suspend) only.

I am trying to imagine what this option is for. When would it be useful?

(Note that this feature doesn't exist on all Unix variants. It's present on Solaris and OpenBSD but not on Linux or FreeBSD. The corresponding setting is stty dsusp.)

Perhaps less subjectively: Is there anything that can be accomplished with Ctrl-Y that cannot be accomplished just as easily with Ctrl-Z?

Answer 1

From the 4BSD manual for csh:

A ^Z takes effect immediately and is like an interrupt in that pending output and unread input are discarded when it is typed. There is another special key ^Y which does not generate a STOP signal until a program attempts to read(2) it. This can usefully be typed ahead when you have prepared some commands for a job which you wish to stop after it has read them.

So, the purpose is to type multiple inputs while the first one is being processed, and have the job stop after they are done.

Answer 2

Say there's a loop reading input and executing. It may be useful to let the task finish the current instruction it computes, without interrupting it before it gets back to the command line for a new one. So thus to end a cycle. This ends the loop gracefully and prevents it from running again if read is under a timeout restriction.

Answer 3

I can think of one scenario where it might be useful, but it's something of a contrived edge-case.

Suppose you're debugging a script that is writing temporary files that you wish to analyze before they're deleted as part of a clean-up routine.

You could add a read foo somewhere after the files are written (but before the cleanup), run the script, and press Ctrl-Y as they're being generated. You will then be dropped to a prompt with the script suspended in the background to do whatever you need to do, and can then fg to allow the script to complete.

Answer 4

The only scenario I can think of (and even I don't find it very convincing), is if you want to use some type-ahead for a shell command. Say some command is running which will read input some time in the future. Then you can ^Y it, and then immediately type the next shell command that you want to have executed when the running command suspends. I don't think I have ever really used this in several decades of using BSD Unix.