Cfrtjryk

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

function cleanup {

    if rmdir $LOCKDIR; then

        echo "Finished"

    else

        echo "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)

    trap "cleanup" EXIT



    echo "Acquired lock, running"



    # Processing starts here

else

    echo "Could not create lock directory '$LOCKDIR'"

    exit 1

fi

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

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

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.

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

#!/bin/bash



# Check if another instance of script is running

pidof -o %PPID -x $0 >/dev/null && echo "ERROR: Script $0 already running" && exit 1



...

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

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 "$0" "$0" "$@" || exit 1



echo "servus!"

sleep 10

This comes from man flock, although I've removed -n from the args to flock, which makes flock fail instead of waiting until other instances are done. You can use a timeout (-w) as well.

The script invokes itself through flock if the environment variable FLOCKER isn't set. In this "recursive" invocation, said variable is set and the line does nothing.

The exit 1 is a safety net so the script terminates unsuccessfully if flock wasn't found. The dash/bash-versions I've tested don't continue execution after an unsuccessful exec, but man flock has || : in it.

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)

See also https://stackoverflow.com/questions/185451/quick-and-dirty-way-to-ensure-only-one-instance-of-a-shell-script-is-running-at.

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

sudo pip install -U pidlock



pidlock -n sleepy_script -c 'sleep 10'

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.

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.