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.