You can do it. TLPI says:

When sent to a stopped process, this signal causes the process to resume (i.e., to be rescheduled to run at some later time). When received by a process that is not currently stopped, this signal is ignored by default. A process may catch this signal, so that it carries out some action when it resumes.

APUE:

Note that the default action for SIGCONT is to continue the process, if it is stopped; otherwise, the signal is ignored.

From the latest version of the kill(2) manpage:

For a process to have permission to send a signal to a process designated by pid, the user must be the super-user, or the real or saved user ID of the receiving process must match the real or effective user ID of the sending process. A single exception is the signal SIGCONT, which may always be sent to any process with the same session ID as the sender. In addition, if the security.bsd.conservative_signals sysctl is set to 1, the user is not a super-user, and the receiver is set-uid, then only job control and terminal control signals may be sent (in particular, only SIGKILL, SIGINT, SIGTERM, SIGALRM, SIGSTOP, SIGTTIN, SIGTTOU, SIGTSTP, SIGHUP, SIGUSR1, SIGUSR2).

In what sense do you own the process? What exactly is the status of the process relating to real uid, effective uid, what binary it is running, owner and setid-bits of that binary, etc?

Not only do you answer your question, the link you added at the end also answers your question.

When a process is stopped, all signal processing is stopped, except for SIGCONT and SIGKILL - which are, in practice handled by the operating system.

This means that SIGHUP can only the handled after the process is resumed, which happens when SIGCONT is recieved and handled, so, even if you send a SIGHUP followed by a SIGCONT, they are going to be handled in the opposite order.

Now, in practice, the kernel sending SIGHUP before will result in less stuff being done by a process between handling SIGCONT and handling SIGHUP, as the second is already queued to be handled.

How do you know that sending SIGCONT doesn't wake up the sleep process? What do you expect to happen? The fg command wakes up the process and brings it to the foreground (hence fg). The bg command wakes up the process and brings it to the background (hence bg).

In implementation details, the shell uses wait on a process in the foreground, while it doesn't use wait on processes in the background.

So after SIGCONT your sleep probably continues to run in the background. You could wait for 100 seconds after sending SIGCONT, then the sleep command should have terminated and you should get a notification (immediately or after pressing return, depending on the configuration of your shell).

When you are killing a process with a kill pid, you are sending a SIGTERM. Sometimes a process is stuck in a state where it won't listen to signals. When that happens, try kill -9 pid and that will probably kill it for good.

In this case, the defunct process (31217) won't be able to be killed, but the parent process (31216) should die and take its child process with it.

You might try set the Docker container with Runtime privilege and Linux capabilities, with the

docker run --privileged

try kill command with with -9 signal if sudo kill 'pid' does not work: sudo kill -9 2092

I had the problem/resolution as Prof.Chaos. NordVPN has an "internet kill switch" that prevents you from accessing internet without the vpn active. Once I activated nordvpn internet worked. Fyi, for options in terminal type:

man nordvpn

To disable this killswitch (which now that you know about it you may not want to)

nordvpn set killswitch disable

Hitting "ctrl-Z" in the shell suspends the current foreground process, by sending it a STOP signal. This (I believe) also results in the process's standard input being detached from the shell - it is now a background process.

The bg command sends a CONTINUE signal to the command, but does not reconnect its standard input to the shell. Since cat is waiting on the standard input, it stays stopped. As you mentioned, the fg command does indeed connect the standard input back yo the shell.

When you send a STOP signal to your process, the shell is notified via a CHILD signal and puts it in the background and the same thing happens.

You can see the difference when you hit "ctrl-Z":

[1]  + 8336 suspended  cat

And when you send a STOP signal manually:

[1]  + 8336 suspended (signal)  cat

This happened to me on my RHEL 8 box. Checked (almost) everything, but at the end I found out that the culprit was fapolicyd running, which restricts execution policies according to file formats, directories, etc.

Maybe someone else running into this issue might have the fapolicyd.