Why process control manages execution in Bash Scripting - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to run a command in the background.

Bash Scripting

sleep 10 [1]

Drag options to blanks, or click blank then click option'

A&

B&&

C|

D;

Attempts:

3 left

💡 Hint

Common Mistakes

Using '&&' runs the next command only if the first succeeds, not backgrounding.

Using '|' pipes output, not backgrounding.

Using ';' runs commands sequentially, not backgrounding.

Adding & at the end of a command runs it in the background, allowing the shell to continue without waiting.

2fill in blank

medium

Complete the code to wait for a background process to finish.

Bash Scripting

sleep 5 &
[1]

Drag options to blanks, or click blank then click option'

Akill

Bwait

Cexit

Dstop

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'stop' does not wait for processes.

Using 'kill' terminates processes instead of waiting.

Using 'exit' ends the script immediately.

The wait command pauses the script until all background jobs finish.

3fill in blank

hard

Fix the error in the code to correctly bring a background job to the foreground.

Bash Scripting

sleep 20 &
[1]

Drag options to blanks, or click blank then click option'

Ajobs 1

Bbg 1

Cfg 1

Dkill 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'bg' keeps the job in the background.

Using 'jobs' lists jobs but does not bring them forward.

Using 'kill' terminates the job.

The fg command brings a background job to the foreground. The number 1 refers to the job ID.

4fill in blank

hard

Fill both blanks to create a loop that runs a command and waits for it to finish before continuing.

Bash Scripting

for i in {1..3}; do
  sleep 2 [1]
  [2]
  echo "Done $i"
done

Drag options to blanks, or click blank then click option'

A&

Bwait

Cfg

Dkill

Attempts:

3 left

💡 Hint

Common Mistakes

Not using '&' causes the loop to wait naturally, no need for wait.

Using 'fg' does not wait but brings jobs to foreground.

Using 'kill' stops the process.

Running sleep 2 & starts the sleep in the background, and wait pauses until it finishes before echoing.

5fill in blank

hard

Fill all three blanks to create a dictionary-like output of job IDs and their statuses.

Bash Scripting

jobs_output=$(jobs)
while read -r line; do
  job_id=$(echo $line | awk [1])
  status=$(echo $line | awk [2])
  echo "Job $[3]: $status"
done <<< "$jobs_output"

Drag options to blanks, or click blank then click option'

A'{print $1}'

B'{print $2}'

Cjob_id

Dstatus

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up field numbers in awk.

Using variable names incorrectly in echo.

Not reading the jobs output line properly.

The first awk prints the job ID (first field), the second prints the status (second field), and the echo uses the job_id variable.

Practice

1. What does the & symbol do when added at the end of a command in a bash script?

easy

A. Runs the command in the background, allowing the script to continue immediately

B. Stops the script execution until the command finishes

C. Runs the command only if the previous command failed

D. Combines two commands to run one after the other

Solution

1. Step 1: Understand the role of & in bash

   The & symbol placed after a command tells bash to run that command in the background.

2. Step 2: Effect on script execution

   Running a command in the background means the script does not wait for it to finish and continues running the next commands immediately.

3. Final Answer:

   Runs the command in the background, allowing the script to continue immediately -> Option A

4. Quick Check:

   & runs command in background [OK]

Hint: Background tasks use & to run without waiting [OK]

Common Mistakes:

• Thinking & waits for command to finish
• Confusing & with && or ||
• Assuming & runs command only on failure

2. Which of the following is the correct syntax to run command2 only if command1 succeeds?

easy

A. command1 & command2

B. command1 || command2

C. command1 && command2

D. command1 ; command2

Solution

1. Step 1: Understand conditional execution operators

   The && operator runs the second command only if the first command succeeds (returns exit status 0).

2. Step 2: Compare options

   || runs second command if first fails, & runs in background, ; runs sequentially regardless of success.

3. Final Answer:

   command1 && command2 -> Option C

4. Quick Check:

   && means run next if success [OK]

Hint: Use && to run next command only on success [OK]

Common Mistakes:

• Using || instead of && for success condition
• Confusing & (background) with &&
• Using ; which ignores command success

3. What will be the output of the following script?

echo "Start" && false && echo "Middle" || echo "End"

medium

A. Start\nEnd

B. End

C. Start\nMiddle

D. Start

Solution

1. Step 1: Evaluate the first command

   echo "Start" runs and succeeds, so next command after && runs.

2. Step 2: Evaluate the second command

   false always fails (exit status non-zero), so the next && echo "Middle" does not run.

3. Step 3: Evaluate the || echo "End"

   Because the chain before || failed, echo "End" runs.

4. Final Answer:

   Start End -> Option A

5. Quick Check:

   Success && fail skips next && runs || next [OK]

Hint: && stops on failure, || runs if previous failed [OK]

Common Mistakes:

• Assuming all commands run sequentially
• Ignoring that false always fails
• Confusing && and || behavior

4. Identify the error in this script snippet:

sleep 5 &
wait
 echo "Done"

medium

A. There is an extra space before echo causing syntax error

B. The ampersand & should be at the end of the wait command

C. The ampersand & is incorrectly placed after sleep 5

D. The wait command is missing a process ID

Solution

1. Step 1: Examine the wait command

   The wait command lacks a process ID argument.

2. Step 2: Behavior of wait without PID

   Without a PID (e.g., $!), wait pauses until all background jobs complete, which may include unintended jobs and cause longer waits.

3. Step 3: Proper fix

   Use sleep 5 & pid=$!; wait $pid or wait $! to target only the sleep job.

4. Final Answer:

   The wait command is missing a process ID -> Option D

5. Quick Check:

   wait w/o PID waits all BG jobs [OK]

Hint: Use wait $! for specific BG job [OK]

Common Mistakes:

• Using wait w/o PID when targeting specific job
• Misplacing & after wait
• Wrongly thinking & after sleep is bad
• Believing leading spaces cause syntax errors

5. You want to run three commands: cmd1, cmd2, and cmd3. Run cmd1 and cmd2 in parallel, then run cmd3 only after both finish successfully. Which script snippet achieves this?

hard

A. cmd1 && cmd2 && cmd3 &

B. cmd1 & cmd2 & wait && cmd3

C. cmd1 & cmd2 && wait && cmd3

D. cmd1 & cmd2 & cmd3 && wait

Solution

1. Step 1: Start cmd1 and cmd2 in background

   cmd1 & cmd2 & launches both commands asynchronously in parallel.

2. Step 2: Wait for both background jobs

   wait pauses script execution until both background jobs finish.

3. Step 3: Run cmd3 after successful completion

   wait && cmd3 ensures cmd3 runs only if both background jobs succeed.

4. Final Answer:

   cmd1 & cmd2 & wait && cmd3 -> Option B

5. Quick Check:

   Both BG jobs & wait then conditional cmd3 [OK]

Hint: Run both commands in background, wait, then run next [OK]

Common Mistakes:

• Running cmd3 before wait finishes
• Not using wait to synchronize background jobs
• Placing & incorrectly causing sequential runs