Run Cron Job Only If It Isn't Already Running in Linux

Cron is a utility in Linux that allows users to schedule commands or scripts to run automatically at a specific date and time. However, sometimes it may be necessary to ensure that a cron job does not run more than once at a time, preventing resource conflicts or data corruption. In this article, we will discuss two effective methods to prevent overlapping cron tasks: using process tracking and using a .pid file.

Method 1: Process Detection with pgrep

One way to avoid overlapping cron task execution is to check for the presence of the task's process before running it. This can be done using the pgrep command, which searches for processes with a specific name and returns their process IDs.

The basic syntax involves adding a process check at the beginning of your script:

if pgrep -x "script_name" > /dev/null ; then
   exit 0
fi

In this command, script_name is the name of the script or command to run as a cron job. The -x option tells pgrep to match the exact process name, and > /dev/null redirects the output to suppress terminal clutter. If the script is already running, the condition becomes true and the new instance exits immediately.

Complete Example Script

#!/bin/bash

# Check if script is already running
if pgrep -x "backup_script.sh" > /dev/null ; then
   echo "Script is already running. Exiting..."
   exit 0
fi

# Your actual script logic here
echo "Running backup process..."
# Simulate long-running task
sleep 300
echo "Backup completed"

Method 2: PID File Locking

A more robust approach uses a .pid file to track running processes. A .pid file is a text file containing the process ID of a running process. This method provides better control and handles edge cases more effectively.

The implementation involves creating a .pid file when the script starts and removing it when the script completes:

pid_file="/path/to/pid/file/task.pid"
if [ -f "$pid_file" ] && kill -0 $(cat "$pid_file") 2>/dev/null; then
    echo "Process already running with PID $(cat "$pid_file")"
    exit 0
fi
echo $$ > "$pid_file"

The kill -0 command sends a null signal to check if the process is still running without actually terminating it. If the process exists, the command succeeds and the script exits. The $$ variable contains the current process ID.

Complete PID File Example

#!/bin/bash

pid_file="/tmp/my_backup.pid"

# Check if already running
if [ -f "$pid_file" ] && kill -0 $(cat "$pid_file") 2>/dev/null; then
   echo "Script already running with PID $(cat "$pid_file")"
   exit 0
fi

# Create PID file
echo $$ > "$pid_file"

# Cleanup function to remove PID file on exit
cleanup() {
    rm -f "$pid_file"
    echo "Cleanup completed"
}

# Set trap to cleanup on script exit
trap cleanup EXIT INT TERM

# Your script logic here
echo "Starting backup process..."
sleep 300
echo "Backup completed"

# PID file automatically removed by trap

Comparison of Methods

Best Practices

• Use descriptive .pid file names that include the script name

• Store .pid files in /tmp or a dedicated directory with proper permissions

• Always use trap commands to ensure cleanup on script termination

• Consider using flock for even more robust file locking

• Test your implementation with overlapping executions to verify behavior

Conclusion

Preventing overlapping cron jobs is essential for maintaining system stability and data integrity. The process detection method offers simplicity, while the PID file approach provides more robust control and better handles edge cases. Choose the method that best fits your specific requirements and always include proper cleanup mechanisms to prevent stale locks.