Lock files for single instance in Bash Scripting - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output of this lock file check script?

Consider this bash script snippet that uses a lock file to ensure a single instance runs. What will it output if the lock file already exists?

Bash Scripting

#!/bin/bash
LOCKFILE=/tmp/mylockfile.lock
if [ -e "$LOCKFILE" ]; then
  echo "Another instance is running. Exiting."
  exit 1
else
  touch "$LOCKFILE"
  echo "Lock acquired. Running script."
  # Simulate work
  sleep 1
  rm "$LOCKFILE"
fi

A Lock acquired. Running script.

B Another instance is running. Exiting.

C No output, script runs silently.

D Error: Permission denied creating lock file.

💡 Hint

Check what happens if the lock file already exists before the script runs.

The script checks if the lock file exists. If it does, it prints the message and exits. So if the lock file is already there, it outputs the message about another instance running.

📝 Syntax

intermediate

Which option correctly creates a lock file atomically?

You want to create a lock file only if it does not exist, atomically, to avoid race conditions. Which bash command snippet does this correctly?

A if mkdir /tmp/mylockdir 2>/dev/null; then echo "Lock acquired"; else echo "Lock exists"; fi

B if touch /tmp/mylockfile.lock; then echo "Lock acquired"; else echo "Lock exists"; fi

C if [ ! -e /tmp/mylockfile.lock ]; then touch /tmp/mylockfile.lock; echo "Lock acquired"; else echo "Lock exists"; fi

D if rm /tmp/mylockfile.lock; then echo "Lock acquired"; else echo "Lock exists"; fi

💡 Hint

Creating a directory is atomic in Unix filesystems.

Using mkdir to create a directory as a lock is atomic. If mkdir succeeds, the lock is acquired. Other methods like touch or checking existence are not atomic and can cause race conditions.

🔧 Debug

advanced

Why does this lock file script fail to prevent multiple instances?

This script is intended to prevent multiple instances by creating a lock file. Why might it fail? #!/bin/bash LOCKFILE=/tmp/mylockfile.lock if [ ! -e "$LOCKFILE" ]; then touch "$LOCKFILE" echo "Lock acquired" sleep 10 rm "$LOCKFILE" else echo "Another instance running" fi

A Because the script removes the lock file too quickly.

B Because the script does not check if the lock file is writable.

C Because the script does not use sudo to create the lock file.

D Because checking -e and then touch is not atomic, two instances can create the lock file simultaneously.

💡 Hint

Think about what happens if two scripts check for the file at the same time.

The check for existence and creation of the lock file are two separate steps, so two scripts can both see the file missing and both create it, causing multiple instances.

🚀 Application

advanced

How to safely release a lock file only if owned by current process?

You want to release a lock file only if it was created by the current script instance. Which approach is safest?

A Use rm -f on the lock file without any checks.

B Always remove the lock file at script end without checking.

C Store the current process ID (PID) inside the lock file and check it before removing the file.

D Ignore the lock file and create a new one with a different name.

💡 Hint

Think about how to avoid removing a lock held by another process.

Writing the PID inside the lock file and verifying it before removal ensures only the owner process removes the lock, preventing accidental unlocking by others.

🧠 Conceptual

expert

What is the main advantage of using flock over manual lock files?

In bash scripting, what is the main advantage of using the flock command to manage single instance locks instead of manually creating lock files?

A flock provides atomic locking with automatic cleanup on process exit, avoiding stale locks.

B flock creates lock files faster than touch or mkdir.

C flock allows multiple scripts to share the same lock simultaneously.

D flock automatically retries lock acquisition indefinitely without blocking.

💡 Hint

Consider what happens if a script crashes with manual lock files.

flock uses kernel-level locks that are automatically released if the process exits, preventing stale locks and race conditions common with manual lock files.

Practice

1. What is the main purpose of using a lock file in a bash script?

easy

A. To prevent multiple instances of the script from running at the same time

B. To speed up the script execution

C. To store user input temporarily

D. To log errors during script execution

Solution

1. Step 1: Understand the role of a lock file

   A lock file is used to signal that a script is already running, preventing duplicates.

2. Step 2: Identify the main purpose

   This prevents multiple script instances from running simultaneously, avoiding conflicts.

3. Final Answer:

   To prevent multiple instances of the script from running at the same time -> Option A

4. Quick Check:

   Lock file purpose = prevent duplicates [OK]

Hint: Lock files stop duplicate script runs quickly [OK]

Common Mistakes:

• Thinking lock files speed up scripts
• Confusing lock files with log files
• Using lock files to store data

2. Which of the following bash commands correctly creates a lock file only if it does not already exist?

easy

A. touch /tmp/myscript.lock

B. echo $$ > /tmp/myscript.lock

C. mkdir /tmp/myscript.lock

D. if [ ! -e /tmp/myscript.lock ]; then touch /tmp/myscript.lock; fi

Solution

1. Step 1: Check for existence before creating

   The command must create the lock file only if it does not exist, so a test with [ ! -e ] is needed.

2. Step 2: Identify the correct syntax

   if [ ! -e /tmp/myscript.lock ]; then touch /tmp/myscript.lock; fi uses an if statement to check and then create the file, which is correct.

3. Final Answer:

   if [ ! -e /tmp/myscript.lock ]; then touch /tmp/myscript.lock; fi -> Option D

4. Quick Check:

   Check existence before touch = if [ ! -e /tmp/myscript.lock ]; then touch /tmp/myscript.lock; fi [OK]

Hint: Use if with [ ! -e ] to create lock file safely [OK]

Common Mistakes:

• Using touch without checking file existence
• Using mkdir which creates a directory, not a file
• Overwriting lock file without check

3. Given this script snippet:

if [ -e /tmp/myscript.lock ]; then
  echo "Script already running"
  exit 1
else
  touch /tmp/myscript.lock
  echo "Running script"
  rm /tmp/myscript.lock
fi

What will be the output if the lock file exists?

medium

A. Running script

B. Script already running

C. No output

D. Error: lock file missing

Solution

1. Step 1: Check the condition when lock file exists

   If /tmp/myscript.lock exists, the if condition is true and the script echoes "Script already running" and exits.

2. Step 2: Understand the output

   Since the script exits early, it does not run or remove the lock file.

3. Final Answer:

   Script already running -> Option B

4. Quick Check:

   Lock file exists = "Script already running" [OK]

Hint: If lock file exists, script exits with message [OK]

Common Mistakes:

• Assuming script runs even if lock file exists
• Expecting no output when lock file exists
• Confusing lock file presence with absence

4. This script is intended to prevent multiple runs using a lock file:

if [ -e /tmp/myscript.lock ]; then
  echo "Already running"
  exit 1
fi

touch /tmp/myscript.lock
# script work here
rm /tmp/myscript.lock

But sometimes multiple instances run simultaneously. What is the likely problem?

medium

A. The lock file is not checked before creation

B. The script does not remove the lock file

C. The lock file is created after the check, causing a race condition

D. The script uses rm instead of rmdir

Solution

1. Step 1: Analyze the timing of lock file creation

   The script checks for the lock file, then creates it. Between these steps, another instance can start and pass the check.

2. Step 2: Identify the race condition

   This gap causes multiple instances to run simultaneously because the lock file is not created atomically with the check.

3. Final Answer:

   The lock file is created after the check, causing a race condition -> Option C

4. Quick Check:

   Race condition from delayed lock creation = The lock file is created after the check, causing a race condition [OK]

Hint: Create lock file atomically to avoid race conditions [OK]

Common Mistakes:

• Ignoring race conditions in lock file creation
• Forgetting to remove lock file after script ends
• Confusing file removal commands

5. You want to write a bash script that runs only one instance at a time using a lock file. Which approach is best to avoid race conditions?

hard

A. Use 'mkdir /tmp/myscript.lock' and check if it succeeds before running

B. Check if lock file exists, then create it with 'touch' if not

C. Create lock file with 'echo $$ > /tmp/myscript.lock' without checking

D. Remove lock file at script start, then create it

Solution

1. Step 1: Understand atomic operations for locking

   Using 'mkdir' to create a directory as a lock is atomic; it either succeeds or fails immediately.

2. Step 2: Compare with other methods

   Other methods like checking then touching can cause race conditions; removing lock at start is unsafe.

3. Final Answer:

   Use 'mkdir /tmp/myscript.lock' and check if it succeeds before running -> Option A

4. Quick Check:

   Atomic mkdir lock = safest method [OK]

Hint: Use mkdir for atomic lock creation to avoid race [OK]

Common Mistakes:

• Using touch without atomic check
• Removing lock file before checking
• Ignoring race conditions