How to make sure only one instance of a bash script runs?

Question

A solution that does not require additional tools would be prefered.

Answer 1

Almost like nsg's answer: use a lock directory. Directory creation is atomic under linux and unix and *BSD and a lot of other OSes.

if mkdir -- "$LOCKDIR"
then
    # Do important, exclusive stuff
    if rmdir -- "$LOCKDIR"
    then
        echo "Victory is mine"
    else
        echo "Could not remove lock dir" >&2
    fi
else
    # Handle error condition
    ...
fi

You can put the PID of the locking sh into a file in the lock directory for debugging purposes, but don't fall into the trap of thinking you can check that PID to see if the locking process still executes. Lots of race conditions lie down that path.

Answer 2

To add to Bruce Ediger's answer, and inspired by this answer, you should also add more smarts to the cleanup to guard against script termination:

#Remove the lock directory
cleanup() {
    if rmdir -- "$LOCKDIR"; then
        echo "Finished"
    else
        echo >&2 "Failed to remove lock directory '$LOCKDIR'"
        exit 1
    fi
}

if mkdir -- "$LOCKDIR"; then
    #Ensure that if we "grabbed a lock", we release it
    #Works for SIGTERM and SIGINT(Ctrl-C) as well in some shells
    #including bash.
    trap "cleanup" EXIT

    echo "Acquired lock, running"

    # Processing starts here
else
    echo >&2 "Could not create lock directory '$LOCKDIR'"
    exit 1
fi

Answer 3

One other way to make sure a single instance of bash script runs:

#! /bin/bash -

# Check if another instance of script is running
if pidof -o %PPID -x -- "$0" >/dev/null; then
  printf >&2 '%s\n' "ERROR: Script $0 already running"
  exit 1
fi

...

pidof -o %PPID -x -- "$0" gets the PID of the existing script¹ if it's already running or exits with error code 1 if no other script is running

---

^{¹ Well, any process with the same name...}

Answer 4

Although you've asked for a solution without additional tools, this is my favourite way using flock:

#!/bin/sh

[ "${FLOCKER}" != "$0" ] && exec env FLOCKER="$0" flock -en "$0" "$0" "$@" || :

echo "servus!"
sleep 10

This comes from the examples section of man flock, which further explains:

This is useful boilerplate code for shell scripts. Put it at the top of the shell script you want to lock and it'll automatically lock itself on the first run. If the env var $FLOCKER is not set to the shell script that is being run, then execute flock and grab an exclusive non-blocking lock (using the script itself as the lock file) before re-execing itself with the right arguments. It also sets the FLOCKER env var to the right value so it doesn't run again.

Points to consider:

• Requires flock, the example script terminates with an error if it can't be found
• Needs no extra lock file
• May not work if the script is on NFS (see https://serverfault.com/questions/66919/file-locks-on-an-nfs)

Update: If your script may get called through different paths (e.g. through its absolute or relative path) or in other words if $0 differs in parallel invocations then the above doesn't work properly. Use a unique environment variable (FLOCK_HAFBX in the example) instead:

[ -z "$FLOCK_HAFBX" ] && exec env FLOCK_HAFBX=1 flock -en "$0" "$0" "$@" || :

The environment variable should be unique so nested flocked scripts work as expected.

Answer 5

This may be too simplistic, please correct me if I'm wrong. Isn't a simple ps enough?

#!/bin/bash 

me="$(basename "$0")";
running=$(ps h -C "$me" | grep -wv $$ | wc -l);
[[ $running > 1 ]] && exit;

# do stuff below this comment

Answer 6

This is a modified version of Anselmo's Answer. The idea is to create a read only file descriptor using the bash script itself and use flock to handle the lock.

script=`realpath $0`     # get absolute path to the script itself
exec 6< "$script"        # open bash script using file descriptor 6
flock -n 6 || { echo "ERROR: script is already running" && exit 1; }   # lock file descriptor 6 OR show error message if script is already running

echo "Run your single instance code here"

The main difference to all other answer's is that this code doesn't modify the filesystem, uses a very low footprint and doesn't need any cleanup since the file descriptor is closed as soon as the script finishes independent of the exit state. Thus it doesn't matter if the script fails or succeeds.

Answer 7

I would use a lock file, as mentioned by Marco

#!/bin/bash

# Exit if /tmp/lock.file exists
[ -f /tmp/lock.file ] && exit

# Create lock file, sleep 1 sec and verify lock
echo $$ > /tmp/lock.file
sleep 1
[ "x$(cat /tmp/lock.file)" == "x"$$ ] || exit

# Do stuff
sleep 60

# Remove lock file
rm /tmp/lock.file

Answer 8

If you want to make sure that only one instance of your script is running take a look at:

Lock your script (against parallel run)

Otherwise you can check ps or invoke lsof <full-path-of-your-script>, since i wouldn't call them additional tools.

---

Supplement:

actually i thought of doing it like this:

for LINE in `lsof -c <your_script> -F p`; do 
    if [ $$ -gt ${LINE#?} ] ; then
        echo "'$0' is already running" 1>&2
        exit 1;
    fi
done

this ensures that only the process with the lowest pid keeps on running even if you fork-and-exec several instances of <your_script> simultaneously.

Answer 9

I am using cksum to check my script is truly running single instance, even I change filename & file path.

I am not using trap & lock file, because if my server suddenly down, I need to remove manually lock file after server goes up.

Note: #!/bin/bash in first line is required for grep ps

#!/bin/bash

checkinstance(){
   nprog=0
   mysum=$(cksum $0|awk '{print $1}')
   for i in `ps -ef |grep /bin/bash|awk '{print $2}'`;do 
        proc=$(ls -lha /proc/$i/exe 2> /dev/null|grep bash) 
        if [[ $? -eq 0 ]];then 
           cmd=$(strings /proc/$i/cmdline|grep -v bash)
                if [[ $? -eq 0 ]];then 
                   fsum=$(cksum /proc/$i/cwd/$cmd|awk '{print $1}')
                   if [[ $mysum -eq $fsum ]];then
                        nprog=$(($nprog+1))
                   fi
                fi
        fi
   done

   if [[ $nprog -gt 1 ]];then
        echo $0 is already running.
        exit
   fi
}

checkinstance 

#--- run your script bellow 

echo pass
while true;do sleep 1000;done

Or you can hardcoded cksum inside your script, so you no worry again if you want to change filename, path, or content of your script.

#!/bin/bash

mysum=1174212411

checkinstance(){
   nprog=0
   for i in `ps -ef |grep /bin/bash|awk '{print $2}'`;do 
        proc=$(ls -lha /proc/$i/exe 2> /dev/null|grep bash) 
        if [[ $? -eq 0 ]];then 
           cmd=$(strings /proc/$i/cmdline|grep -v bash)
                if [[ $? -eq 0 ]];then 
                   fsum=$(grep mysum /proc/$i/cwd/$cmd|head -1|awk -F= '{print $2}')
                   if [[ $mysum -eq $fsum ]];then
                        nprog=$(($nprog+1))
                   fi
                fi
        fi
   done

   if [[ $nprog -gt 1 ]];then
        echo $0 is already running.
        exit
   fi
}

checkinstance

#--- run your script bellow

echo pass
while true;do sleep 1000;done

Answer 10

This handy package does what you're looking for.

https://github.com/krezreb/singleton

once installed, just prefix your command with singleton LOCKNAME

e.g. singleton LOCKNAME PROGRAM ARGS...

Answer 11

Another approach not mentioned here that does not use flock is to rely on the fact that creating a link is atomic.

Given this script:

#!/bin/bash

touch /var/tmp/singleton.$$.lock
if ( link /var/tmp/singleton.$$.lock /var/tmp/singleton.lock 2>/dev/null ) ; then
  echo 'Lock Acquired By: ' $$
  sleep 2
  echo 'Lock Released By: ' $$
  rm /var/tmp/singleton.lock /var/tmp/singleton.$$.lock
else
  echo 'Failed Lock Acquistion Attempt By: ' $$
  rm /var/tmp/singleton.$$.lock
fi

When you try to run multiple instances simultaneously, only one of them acquires the "lock":

§ for i in {1..3}; do (./singleton.sh &) ; done ; sleep 3
Lock Acquired By:  3816
Failed Lock Acquistion Attempt By:  3820
Failed Lock Acquistion Attempt By:  3818
Lock Released By:  3816

You can modify this script to add the appropriate trap statements to make it robust in the event that your script does not exit gracefully.

The basic idea is that when two instances of the script run, they try to create a link at the same path (i.e., /var/tmp/singleton.lock) that points to something, but only one of them will succeed and the other one will get the error code for the error:

ln: failed to create hard link '/var/tmp/singleton.lock': File exists

In this script, the something happens to be an empty file that has the PID of the executing script. You could use other schemes for what something could be but the important bit is that the two instances of the script try to create a link at the same path.

Answer 12

You can use this: https://github.com/sayanarijit/pidlock

sudo pip install -U pidlock

pidlock -n sleepy_script -c 'sleep 10'

Answer 13

My code to you

#!/bin/bash

script_file="$(/bin/readlink -f $0)"
lock_file=${script_file////_}

function executing {
  echo "'${script_file}' already executing"
  exit 1
}

(
  flock -n 9 || executing

  sleep 10

) 9> /var/lock/${lock_file}

Based on man flock, improving only:

• the name of the lock file, to be based on the full name of the script
• the message executing

Where I put here the sleep 10, you can put all the main script.

Answer 14

Easiest one liner script rather than writing complex PID or lock statements

flock -xn LOCKFILE.lck -c SCRIPT.SH

where x denotes exclusive lock and n denotes non-blocking which fails rather than wait for the lock to be released. c runs the script that you want to launch.