Job Control in the Shell

1. Foreground vs. Background Processes

When you type a command and press Enter, it typically runs in the foreground. This means the process takes control of your terminal. You can't type new commands until the current one finishes. A simple example is sleep 30; your terminal will be unresponsive for 30 seconds.

A background process, on the other hand, runs without taking control of your terminal. You can start a long-running task in the background and immediately get your command prompt back to continue working.

The shell provides tools to manage these processes, which it tracks as jobs. A job is essentially a shell's internal wrapper for a process or a group of related processes (like a command pipeline).

2. Managing Foreground Jobs: Suspending and Terminating

You already know one way to interact with a foreground job: terminating it.

• Ctrl+C: Sends the SIGINT (interrupt) signal, which usually tells the process to terminate.

But what if you don't want to kill the process, just get your shell back temporarily? For that, you can suspend it.

• Ctrl+Z: Sends the SIGTSTP (terminal stop) signal, which pauses the process and returns control of the terminal to you.

When you suspend a job, it is paused and is not consuming CPU cycles, but it still exists in memory.

3. Juggling Jobs: jobs, bg, and fg

Once you have a stopped job (or several), you need a way to manage them.

Listing Jobs with jobs

The jobs command lists all the jobs associated with your current shell session, showing their job number and status (e.g., Running or Stopped).

jobs

The output might look like this:

[1]+  Stopped                 sleep 100
[2]-  Stopped                 vim my_script.sh

The + indicates the most recently used job, and - indicates the second most recent. These are the defaults for commands like fg and bg.

Running a Job in the Background with bg

A suspended job is not doing anything. To make it resume execution in the background, you use the bg (background) command.

bg %1  # Resumes job 1 in the background

If you run bg without a job number, it will resume the most recent job (the one marked with +).

Starting a Job Directly in the Background

The most common way to start a background job is to append an ampersand (&) to the end of the command.

find / -name "*.log" > log_files.txt &
[1] 23451

The shell immediately returns a job number ([1]) and the Process ID (23451), and you get your prompt back while find does its work.

Bringing a Job to the Foreground with fg

If you need to interact with a background job again, you can bring it to the foreground with the fg (foreground) command.

fg %1  # Brings job 1 to the foreground

Running fg by itself will bring the most recent job to the foreground.

Let's watch a series of clips that demonstrates these core commands.

This image provides a great visual summary of the workflow:

./data_processing.sh &
# Now you can immediately check the log file
less /var/log/syslog

./data_processing.sh
^Z
[1]+  Stopped                 ./data_processing.sh
bg
[1]+ ./data_processing.sh &
# Now you can immediately check the log file
less /var/log/syslog

4. Terminating Background Jobs

To terminate a background job, you use the kill command, but instead of a PID, you can give it a job specification (or "jobspec"). The most common jobspec is the job number prefixed with a percent sign (%).

kill %1

It is crucial to use the % symbol. If you typed kill 1, the system would try to kill process ID 1, which is the init system—a very different and protected process!

Beyond %n, there are other useful jobspecs.

• %n: Job number n.
• %% or %+: The most recent job.
• %-: The second most recent job.

So, fg is equivalent to fg %%, and kill %- would kill the second-to-last job you backgrounded or suspended.

5. Keeping Jobs Alive: nohup and disown

What happens to your background jobs if you close the terminal or your SSH connection is lost? The shell sends a SIGHUP (hangup) signal to all its jobs, causing them to terminate. To prevent this, you can use nohup or disown.

• nohup: Use this when you start a command. It makes the process immune to the SIGHUP signal. Any output that would normally go to the terminal is redirected to a file named nohup.out.

  nohup long_running_command.sh &
  

• disown: Use this for a job that is already running. It removes the job from the shell's job list, so the shell will no longer send it a SIGHUP signal.

  # Suppose you have job %1 running
  disown %1
  

For further reading on all the topics we've covered, the DigitalOcean article "How To Use Bash's Job Control" (LINK) serves as an excellent written reference.

Conclusion

You've just learned a powerful set of tools for managing processes interactively within a single shell session. This allows you to run multiple tasks, switch between them, and ensure long-running jobs are not accidentally terminated.

Key Takeaways:

• Foreground vs. Background: Foreground jobs block your shell; background jobs do not.
• Key Shortcuts: Ctrl+C terminates a foreground job, while Ctrl+Z suspends it.
• Core Commands:
  • command &: Starts a command in the background.
  • jobs: Lists all jobs in the current session.
  • bg [%job]: Resumes a suspended job in the background.
  • fg [%job]: Brings a background or suspended job to the foreground.
  • kill %job: Terminates a job using its jobspec.
• Persistence: nohup and disown are used to prevent jobs from being terminated when the shell session ends.

Preview of the Next Lesson:

So far, we have focused on managing individual processes and jobs that you start yourself. In our next lesson, we will move to a higher level of process management: inspecting service status and logs using systemctl. This will introduce you to the world of system services—the daemons that run persistently in the background to provide core system functionality.