Ensure Only One Instance of a Bash Script Is Running on Linux


When running a bash script on Linux, it's important to ensure that only one instance of the script is running at a time. This is especially important for scripts that perform critical tasks, such as scripts that update databases or scripts that send email. Running multiple instances of the same script simultaneously can cause conflicts, data loss, and other errors. In this article, we will discuss different methods to ensure that only one instance of a bash script runs on Linux.

Using Flock

One way to ensure that only one instance of a bash script runs on Linux is to use the “flock” command. The flock command is used to create a lock on a file and is a command built into most shells such as Bash, Zsh, etc. It's a simple and efficient way to ensure that only one instance of a script runs at a time.

We can trust this approach because there will be no race conditions. Also, all locks on a file are released when the process completes. These benefits make flocking a safe way to ensure that only one instance is running. Another benefit is that the flock program is an implementation of the flock system call.

flock by default blocks until the lock is released and then continues without errors. We can use the “-n” parameter to use flock in a non-blocking way. This will cause flock to exit immediately with an error when there is another lock on the file.

We can use flock to run an external script or use it inside the script.

Running an External Script

We can use flock in a script like this −

$ flock -n /var/lock/dobackup.lock ./dobackup.sh

Now let's assume that our script is currently running. Let's see what happens if we execute the previous line again −

$ flock --verbose -n /var/lock/dobackup.lock ./dobackup.sh
flock: failed to get lock
$ echo $?

We can see that flock informed us that it could not acquire the lock and exited with the value 1 (error). This means that another instance has the lock.

When flock fails, it does not run the script parameter, which prevents more than one instance of “dobackup.sh” from running.

Using Flock within the Script

We can use flock inside the script like this −

   echo "There is another instance running, exiting"
   exit 1
( flock -n 100 || another_instance DEST=/home/backup/`date +%s` mkdir -p "$DEST" rsync -avz root@host:/home/web "$DEST/." ) 100>/var/lock/dobackup.lock

In this case, we call flock with a file descriptor and enclose everything we need to protect in square brackets (a subshell) and redirect it to the file we use as lock. We call flock at the beginning with the file descriptor used in the redirect. So if flock exits with an error, we know there is another instance running.

Once the sublevel is finished, the lock file is closed and the lock is automatically released.

Using the Pid File

Another way to ensure that only one instance of a bash script runs on Linux is to use a pid file. A pid file is a special file that contains the process ID (PID) of the running script. By checking the pid file, we can determine if the script is already running and if so, exit the script with an error message.

To implement this method, we can add the following code to the beginning of our script −

if [ -f /path/to/pidfile ]; then
   pid=$(cat /path/to/pidfile)
   if kill -0 $pid 2>/dev/null; then
      echo "Script is already running"
      exit 1
      echo $$ > /path/to/pidfile
   echo $$ > /path/to/pidfile

This code checks for the presence of the pid file in the specified path. If the pid file exists, the script reads the pid from the file and checks if the process is still running by sending a null signal (kill -0) to the process. If the process is still running, the script exits with an error message. If the process is not running, the script overwrites the pid file with the current process id. If the pid file does not exist, the script creates it and writes the current process id.

At the end of the script, you can add the following code to remove the pid file −

$ rm -f /path/to/pidfile


Making sure that only one instance of a bash script runs on Linux is an important task that can prevent conflicts, data loss, and other errors. There are several methods of doing this, such as using a lock file with the flock command, using the pid file, or using the “pgrep” and “kill” commands. Each method has its advantages and disadvantages, and the best method for your script will depend on your specific requirements. By implementing any of these methods, you can ensure that your script runs smoothly and without errors.