Quick-and-dirty way to ensure only one instance of a shell script is running at a time

Question

What s a quick-and-dirty way to make sure that only one instance of a shell script is running at a given time

User · Answer

Using the process s lock is much stronger and takes care of the ungraceful exits also  lock file is kept open as long as the process is running  It will be closed  by shell  once the process exists  even if it gets killed    I found this to be very efficient   lock file  tmp  basename  0  lock  if fuser  lock file  gt   dev null 2 gt  amp 1  then     echo  WARNING  Other instance of   basename  0  running       exit 1 fi exec 3 gt   lock file

User · Answer

I use oneliner   the very beginning of script      bin bash  if      pgrep -afc    basename   0     -gt  1      then echo  Another instance of   0  has already been started    amp  amp  exit  fi   the beginning of actual script   It is good to see the presence of process in the memory  no matter what the status of process is   but it does the job for me

User · Answer

Take a look to FLOM  Free LOck Manager  http   sourceforge net projects flom   you can synchronize commands and or scripts using abstract resources that does not need lock files in a filesystem  You can synchronize commands running in different systems without a NAS  Network Attached Storage  like an NFS  Network File System  server   Using the simplest use case  serializing  command1  and  command2  may be as easy as executing   flom -- command1   and  flom -- command2   from two different shell scripts

User · Answer

For shell scripts  I tend to go with the mkdir over flock as it makes the locks more portable   Either way  using set -e isn t enough  That only exits the script if any command fails  Your locks will still be left behind   For proper lock cleanup  you really should set your traps to something like this psuedo code  lifted  simplified and untested but from actively used scripts                                                                                Predefined Global Variables                                                                           TMPDIR  tmp myapp      -d  TMP DIR           amp  amp  mkdir -p  TMP DIR        amp  amp  chmod 700  TMPDIR  LOCK DIR  TMP DIR lock                                                                             Functions                                                                           function mklock         lockdir   LOCK DIR   date   s  N        Private Global  Use Epoch Nano PID        If it can create  LOCK DIR then no other instance is running     if   mkdir  LOCK DIR      then         mkdir    lockdir    create this instance s specific lock in queue         LOCK EXISTS true    Global     else         echo  FATAL  Lock already exists  Another copy is running or manually lock clean up required           exit 1001    Or work out some sleep while execution lock elsewhere     fi    function rmlock            -d    lockdir               amp  amp  echo  WARNING  Lock is missing     lockdir does not exist               rmdir    lockdir     -----------------------------------------------------------------------   Private Signal Traps Functions    2     DANGER  SIGKILL cannot be trapped  So  try not to  kill -9 PID  or            there will be  NO CLEAN UP   You ll have to manually remove            any locks in place   ----------------------------------------------------------------------- function   sig exit          Place your clean up logic here         Remove the LOCK        -n  LOCK EXISTS     amp  amp  rmlock    function   sig int       echo  WARNING  SIGINT caught          exit 1002    function   sig quit       echo  SIGQUIT caught      exit 1003    function   sig term       echo  WARNING  SIGTERM caught          exit 1015                                                                               Main                                                                             Set TRAPs trap   sig exit EXIT      SIGEXIT trap   sig int INT        SIGINT trap   sig quit QUIT      SIGQUIT trap   sig term TERM      SIGTERM  mklock    CODE  exit   No need for cleanup code here being in the   sig exit trap function   Here s what will happen  All traps will produce an exit so the function   sig exit will always happen  barring a SIGKILL  which cleans up your locks   Note  my exit values are not low values  Why  Various batch processing systems make or have expectations of the numbers 0 through 31  Setting them to something else  I can have my scripts and batch streams react accordingly to the previous batch job or script

User · Answer

Late to the party  using the idea from  Majal  this is my script to start only one instance of emacsclient GUI  With it  I can set shortcutkey to open or jump back to the same emacsclient  I have another script to call emacsclient in terminals when I need it  The use of emacsclient here is just to show a working example  one can choose something else  This approach is quick and good enough for my tiny scripts  Tell me where it is dirty        bin bash    if     pgrep -c   basename  0   -lt 2    then   this works but requires script name to be unique if     pidof -x   0  wc -w   -lt 3    then     echo -e  Starting   basename  0       emacsclient --alternate-editor    -c      else     echo -e   0 is running already  fi

User · Answer

Using the process s lock is much stronger and takes care of the ungraceful exits also  lock file is kept open as long as the process is running  It will be closed  by shell  once the process exists  even if it gets killed    I found this to be very efficient   lock file  tmp  basename  0  lock  if fuser  lock file  gt   dev null 2 gt  amp 1  then     echo  WARNING  Other instance of   basename  0  running       exit 1 fi exec 3 gt   lock file

User · Answer

The flock path is the way to go  Think about what happens when the script suddenly dies  In the flock-case you just loose the flock  but that is not a problem  Also  note that an evil trick is to take a flock on the script itself    but that of course lets you run full-steam-ahead into permission problems

User · Answer

An example with flock 1  but without subshell  flock  ed file  tmp foo is never removed  but that doesn t matter as it gets flock   and un-flock  ed      bin bash  exec 9 lt  gt   tmp foo flock -n 9 RET    if     RET -ne 0      then     echo  lock failed  exiting      exit fi   Now we are inside the  critical section  echo  inside lock  sleep 5 exec 9 gt  amp -  close fd 9  and release lock   The part below is outside the critical section  the lock  echo  lock released  sleep 5

User · Answer

To make locking reliable you need an atomic operation  Many of the above proposals are not atomic  The proposed lockfile 1  utility looks promising as the man-page mentioned  that its  NFS-resistant   If your OS does not support lockfile 1  and your solution has to work on NFS  you have not many options      NFSv2 has two atomic operations    symlink rename   With NFSv3 the create call is also atomic   Directory operations are NOT atomic under NFSv2 and NFSv3  please refer to the book  NFS Illustrated  by Brent Callaghan  ISBN 0-201-32570-5  Brent is a NFS-veteran at Sun    Knowing this  you can implement spin-locks for files and directories  in shell  not PHP    lock current dir   while   ln -s   lock  do    done   lock a file   while   ln -s   f    f  lock  do    done   unlock current dir  assumption  the running process really acquired the lock    mv lock deleteme  amp  amp  rm deleteme   unlock a file  assumption  the running process really acquired the lock    mv   f  lock   f  deleteme  amp  amp  rm   f  deleteme   Remove is also not atomic  therefore first the rename  which is atomic  and then the remove   For the symlink and rename calls  both filenames have to reside on the same filesystem  My proposal  use only simple filenames  no paths  and put file and lock into the same directory

User · Answer

I use a simple approach that handles stale lock files   Note that some of the above solutions that store the pid  ignore the fact that the pid can wrap around  So - just checking if there is a valid process with the stored pid is not enough  especially for long running scripts   I use noclobber to make sure only one script can open and write to the lock file at one time  Further  I store enough information to uniquely identify a process in the lockfile  I define the set of data to uniquely identify a process to be pid ppid lstart    When a new script starts up  if it fails to create the lock file  it then verifies that the process that created the lock file is still around  If not  we assume the original process died an ungraceful death  and left a stale lock file  The new script then takes ownership of the lock file  and all is well the world  again   Should work with multiple shells across multiple platforms  Fast  portable and simple      usr bin env sh   Author  rouble  LOCKFILE  var tmp lockfile  customize this line  trap release INT TERM EXIT    Creates a lockfile  Sets global variable  ACQUIRED to true on success       Returns 0 if it is successfully able to create lockfile  acquire          set -C  Shell noclobber option  If file exists   gt  will fail      UUID  ps -eo pid ppid lstart      tail -1      if  echo   UUID   gt    LOCKFILE   2 gt  dev null  then         ACQUIRED  TRUE          return 0     else         if   -e  LOCKFILE    then                We may be dealing with a stale lock file                Bring out the magnifying glass               CURRENT UUID FROM LOCKFILE  cat  LOCKFILE              CURRENT PID FROM LOCKFILE  cat  LOCKFILE   cut -f 1 -d                  CURRENT UUID FROM PS  ps -eo pid ppid lstart  CURRENT PID FROM LOCKFILE   tail -1              if     CURRENT UUID FROM LOCKFILE       CURRENT UUID FROM PS     then                  echo  Script already running with following identification   CURRENT UUID FROM LOCKFILE   gt  amp 2                 return 1             else                   The process that created this lock file died an ungraceful death                     Take ownership of the lock file                  echo  The process  CURRENT UUID FROM LOCKFILE is no longer around  Taking ownership of  LOCKFILE                  release  FORCE                  if  echo   UUID   gt    LOCKFILE   2 gt  dev null  then                     ACQUIRED  TRUE                      return 0                 else                     echo  Cannot write to  LOCKFILE  Error    gt  amp 2                     return 1                 fi             fi         else             echo  Do you have write permissons to  LOCKFILE     gt  amp 2             return 1         fi     fi      Removes the lock file only if this script created it   ACQUIRED is set      OR  if we are removing a stale lock file  first parameter is  FORCE    release           Destroy lock file  Take no prisoners      if     ACQUIRED           1      FORCE     then         rm -f  LOCKFILE     fi      Test code   int main  int argc  const char  argv     echo  Acquring lock   acquire if      -eq 0    then      echo  Acquired lock       read -p  Press  Enter  key to release lock         release     echo  Released lock   else     echo  Unable to acquire lock   fi

User · Answer

PID and lockfiles are definitely the most reliable   When you attempt to run the program  it can check for the lockfile which and if it exists  it can use ps to see if the process is still running   If it s not  the script can start  updating the PID in the lockfile to its own

User · Answer

why dont we use something like   pgrep -f  cmd     cmd

User · Answer

You can use GNU Parallel for this as it works as a mutex when called as sem  So  in concrete terms  you can use   sem --id SCRIPTSINGLETON yourScript   If you want a timeout too  use   sem --id SCRIPTSINGLETON --semaphoretimeout -10 yourScript   Timeout of  lt 0 means exit without running script if semaphore is not released within the timeout  timeout of  0 mean run the script anyway   Note that you should give it a name  with --id  else it defaults to the controlling terminal   GNU Parallel is a very simple install on most Linux OSX Unix platforms - it is just a Perl script

User · Answer

Create a lock file in a known location and check for existence on script start  Putting the PID in the file might be helpful if someone s attempting to track down an errant instance that s preventing execution of the script

User · Answer

Add this line at the beginning of your script       FLOCKER        0     amp  amp  exec env FLOCKER   0  flock -en   0    0              It s a boilerplate code from man flock   If you want more logging  use this one       FLOCKER        0     amp  amp    echo  Trying to start build from queue       exec bash -c  FLOCKER   0  flock -E  E LOCKED -en   0    0          if           -eq  E LOCKED    then echo  Locked    fi        echo  Lock is free  Completing     This sets and checks locks using flock utility  This code detects if it was run first time by checking FLOCKER variable  if it is not set to script name  then it tries to start script again recursively using flock and with FLOCKER variable initialized  if FLOCKER is set correctly  then flock on previous iteration succeeded and it is OK to proceed  If lock is busy  it fails with configurable exit code   It seems to not work on Debian 7  but seems to work back again with experimental util-linux 2 25 package  It writes  flock      Text file busy   It could be overridden by disabling write permission on your script

User · Answer

I find that bmdhack s solution is the most practical  at least for my use case  Using flock and lockfile rely on removing the lockfile using rm when the script terminates  which can t always be guaranteed  e g   kill -9    I would change one minor thing about bmdhack s solution  It makes a point of removing the lock file  without stating that this is unnecessary for the safe working of this semaphore  His use of kill -0 ensures that an old lockfile for a dead process will simply be ignored over-written   My simplified solution is therefore to simply add the following to the top of your singleton      Test the lock LOCKFILE  tmp singleton lock  if   -e   LOCKFILE     amp  amp  kill -0  cat   LOCKFILE    then     echo  Script already running  bye       exit  fi     Set the lock  echo     gt    LOCKFILE    Of course  this script still has the flaw that processes that are likely to start at the same time have a race hazard  as the lock test and set operations are not a single atomic action  But the proposed solution for this by lhunath to use mkdir has the flaw that a killed script may leave behind the directory  thus preventing other instances from running

User · Answer

This example is explained in the man flock  but it needs some impovements  because we should manage bugs and exit codes         bin bash     set -e this is useful only for very stupid scripts because script fails when anything command exits with status more than 0    without possibility for capture exit codes  not all commands exits  gt 0 are failed      start subprocess     Wait for lock on  var lock  myscript exclusivelock  fd 200  for 10 seconds   flock -x -w 10 200   if            0     then echo Cannot lock   exit 1  fi   echo    gt  gt  var lock  myscript exclusivelock  for backward lockdir compatibility  notice this command is executed AFTER command bottom    200 gt  var lock  myscript exclusivelock      Do stuff     you can properly manage exit codes with multiple command and process algorithm      I suggest throw this all to external procedure than can properly handle exit X commands    200 gt  var lock  myscript exclusivelock    exit subprocess  FLOCKEXIT      save exitcode status      do some finish commands  exit  FLOCKEXIT    return properly exitcode  may be usefull inside external scripts   You can use another method  list processes that I used in the past  But this is more complicated that method above  You should list processes by ps  filter by its name  additional filter  grep -v grep for remove parasite nad finally count it by grep -c    and compare with number  Its complicated and uncertain

User · Answer

PID and lockfiles are definitely the most reliable   When you attempt to run the program  it can check for the lockfile which and if it exists  it can use ps to see if the process is still running   If it s not  the script can start  updating the PID in the lockfile to its own

User · Answer

This example is explained in the man flock  but it needs some impovements  because we should manage bugs and exit codes         bin bash     set -e this is useful only for very stupid scripts because script fails when anything command exits with status more than 0    without possibility for capture exit codes  not all commands exits  gt 0 are failed      start subprocess     Wait for lock on  var lock  myscript exclusivelock  fd 200  for 10 seconds   flock -x -w 10 200   if            0     then echo Cannot lock   exit 1  fi   echo    gt  gt  var lock  myscript exclusivelock  for backward lockdir compatibility  notice this command is executed AFTER command bottom    200 gt  var lock  myscript exclusivelock      Do stuff     you can properly manage exit codes with multiple command and process algorithm      I suggest throw this all to external procedure than can properly handle exit X commands    200 gt  var lock  myscript exclusivelock    exit subprocess  FLOCKEXIT      save exitcode status      do some finish commands  exit  FLOCKEXIT    return properly exitcode  may be usefull inside external scripts   You can use another method  list processes that I used in the past  But this is more complicated that method above  You should list processes by ps  filter by its name  additional filter  grep -v grep for remove parasite nad finally count it by grep -c    and compare with number  Its complicated and uncertain

User · Answer

All approaches that test the existence of  lock files  are flawed   Why   Because there is no way to check whether a file exists and create it in a single atomic action   Because of this  there is a race condition that WILL make your attempts at mutual exclusion break   Instead  you need to use mkdir   mkdir creates a directory if it doesn t exist yet  and if it does  it sets an exit code   More importantly  it does all this in a single atomic action making it perfect for this scenario   if   mkdir  tmp myscript lock 2 gt  dev null  then     echo  Myscript is already running    gt  amp 2     exit 1 fi   For all details  see the excellent BashFAQ  http   mywiki wooledge org BashFAQ 045  If you want to take care of stale locks  fuser 1  comes in handy   The only downside here is that the operation takes about a second  so it isn t instant   Here s a function I wrote once that solves the problem using fuser           mutex file     Open a mutual exclusion lock on the file  unless another process already owns one      If the file is already locked by another process  the operation fails    This function defines a lock on a file as having a file descriptor open to the file    This function uses FD 9 to open a lock on the file   To release the lock  close FD 9    exec 9 gt  amp -   mutex         local file  1 pid pids       exec 9 gt  gt   file        pids   fuser -f   file      2 gt  amp - 9 gt  amp -      for pid in  pids  do             pid          amp  amp  continue          exec 9 gt  amp -          return 1   Locked by a pid      done      You can use it in a script like so   mutex  var run myscript lock      echo  Already running    gt  amp 2  exit 1      If you don t care about portability  these solutions should work on pretty much any UNIX box   Linux  fuser 1  offers some additional options and there is also flock 1

User · Answer

The flock path is the way to go  Think about what happens when the script suddenly dies  In the flock-case you just loose the flock  but that is not a problem  Also  note that an evil trick is to take a flock on the script itself    but that of course lets you run full-steam-ahead into permission problems

User · Answer

Add this line at the beginning of your script       FLOCKER        0     amp  amp  exec env FLOCKER   0  flock -en   0    0              It s a boilerplate code from man flock   If you want more logging  use this one       FLOCKER        0     amp  amp    echo  Trying to start build from queue       exec bash -c  FLOCKER   0  flock -E  E LOCKED -en   0    0          if           -eq  E LOCKED    then echo  Locked    fi        echo  Lock is free  Completing     This sets and checks locks using flock utility  This code detects if it was run first time by checking FLOCKER variable  if it is not set to script name  then it tries to start script again recursively using flock and with FLOCKER variable initialized  if FLOCKER is set correctly  then flock on previous iteration succeeded and it is OK to proceed  If lock is busy  it fails with configurable exit code   It seems to not work on Debian 7  but seems to work back again with experimental util-linux 2 25 package  It writes  flock      Text file busy   It could be overridden by disabling write permission on your script

User · Answer

Here is a more elegant  fail-safe  quick  amp  dirty method  combining the answers provided above   Usage   include sh lock functions sh init using sh lock init lock using sh acquire lock check lock using sh check lock unlock using sh remove lock   Script File  sh lock functions sh     bin bash  function sh lock init       sh lock scriptName   basename  0      sh lock dir   tmp   sh lock scriptName  lock   lock directory     sh lock file    sh lock dir  lockPid txt   lock file    function sh acquire lock       if mkdir  sh lock dir 2 gt  dev null  then  check for lock         echo   sh lock scriptName lock acquired successfully   gt  amp 2         touch  sh lock file         echo     gt   sh lock file   set current pid in lockFile         return 0     else         touch  sh lock file         read sh lock lastPID  lt   sh lock file         if     -z   sh lock lastPID  -a -d  proc  sh lock lastPID    then   if lastPID is not null and a process with that pid exists             echo   sh lock scriptName is already running   gt  amp 2             return 1         else             echo   sh lock scriptName stopped during execution  reacquiring lock   gt  amp 2             echo     gt   sh lock file   set current pid in lockFile             return 2         fi     fi     return 0    function sh check lock            -f  sh lock file     amp  amp  echo   sh lock scriptName lock file removed   gt  amp 2  amp  amp  return 1     read sh lock lastPID  lt   sh lock file         sh lock lastPID -ne        amp  amp  echo   sh lock scriptName lock file pid has changed   gt  amp 2   amp  amp  return 2     echo   sh lock scriptName lock still in place   gt  amp 2     return 0    function sh remove lock       rm -r  sh lock dir     Usage example  sh lock usage example sh     bin bash    path to sh lock functions sh   load sh lock functions  sh lock init    exit     sh acquire lock lockStatus        lockStatus -eq 1     amp  amp  exit  lockStatus     lockStatus -eq 2     amp  amp  echo  lock is set  do some resume from crash procedures     monitoring example cnt 0 while sh check lock   loop while lock is in place do     echo   sh scriptName running  pid          sleep 1     let cnt           cnt -gt 5     amp  amp  break done   remove lock when process finished sh remove lock    exit     exit 0   Features   Uses a combination of file  directory and process id to lock to make sure that the process is not already running You can detect if the script stopped before lock removal  eg  process kill  shutdown  error etc   You can check the lock file  and use it to trigger a process shutdown when the lock is missing Verbose  outputs error messages for easier debug

User · Answer

Answered a million times already  but another way  without the need for external dependencies   LOCK FILE   var lock   basename   0   pid  trap  rm -f   LOCK FILE   exit  INT TERM EXIT if    -f  LOCK FILE  amp  amp  -d  proc  cat  LOCK FILE      then       Process already exists    exit 1 fi echo     gt   LOCK FILE   Each time it writes the current PID      into the lockfile and on script startup checks if a process is running with the latest PID

User · Answer

To make locking reliable you need an atomic operation  Many of the above proposals are not atomic  The proposed lockfile 1  utility looks promising as the man-page mentioned  that its  NFS-resistant   If your OS does not support lockfile 1  and your solution has to work on NFS  you have not many options      NFSv2 has two atomic operations    symlink rename   With NFSv3 the create call is also atomic   Directory operations are NOT atomic under NFSv2 and NFSv3  please refer to the book  NFS Illustrated  by Brent Callaghan  ISBN 0-201-32570-5  Brent is a NFS-veteran at Sun    Knowing this  you can implement spin-locks for files and directories  in shell  not PHP    lock current dir   while   ln -s   lock  do    done   lock a file   while   ln -s   f    f  lock  do    done   unlock current dir  assumption  the running process really acquired the lock    mv lock deleteme  amp  amp  rm deleteme   unlock a file  assumption  the running process really acquired the lock    mv   f  lock   f  deleteme  amp  amp  rm   f  deleteme   Remove is also not atomic  therefore first the rename  which is atomic  and then the remove   For the symlink and rename calls  both filenames have to reside on the same filesystem  My proposal  use only simple filenames  no paths  and put file and lock into the same directory

User · Answer

To make locking reliable you need an atomic operation  Many of the above proposals are not atomic  The proposed lockfile 1  utility looks promising as the man-page mentioned  that its  NFS-resistant   If your OS does not support lockfile 1  and your solution has to work on NFS  you have not many options      NFSv2 has two atomic operations    symlink rename   With NFSv3 the create call is also atomic   Directory operations are NOT atomic under NFSv2 and NFSv3  please refer to the book  NFS Illustrated  by Brent Callaghan  ISBN 0-201-32570-5  Brent is a NFS-veteran at Sun    Knowing this  you can implement spin-locks for files and directories  in shell  not PHP    lock current dir   while   ln -s   lock  do    done   lock a file   while   ln -s   f    f  lock  do    done   unlock current dir  assumption  the running process really acquired the lock    mv lock deleteme  amp  amp  rm deleteme   unlock a file  assumption  the running process really acquired the lock    mv   f  lock   f  deleteme  amp  amp  rm   f  deleteme   Remove is also not atomic  therefore first the rename  which is atomic  and then the remove   For the symlink and rename calls  both filenames have to reside on the same filesystem  My proposal  use only simple filenames  no paths  and put file and lock into the same directory

User · Answer

Create a lock file in a known location and check for existence on script start  Putting the PID in the file might be helpful if someone s attempting to track down an errant instance that s preventing execution of the script

User · Answer

This one line answer comes from someone related Ask Ubuntu Q amp A        FLOCKER        0     amp  amp  exec env FLOCKER   0  flock -en   0    0                  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

User · Answer

if   1 -ne    bin fuser   0  2 gt  dev null   wc -w     then     exit 1 fi

User · Answer

I wanted to do away with lockfiles  lockdirs  special locking programs and even pidof since it isn t found on all Linux installations  Also wanted to have the simplest code possible  or at least as few lines as possible   Simplest if statement  in one line   if      ps axf   awk -v pid      1  pid  amp  amp   6     basename  0    print  1        then echo  Already running   exit  fi

User · Answer

There s a wrapper around the flock 2  system call called  unimaginatively  flock 1   This makes it relatively easy to reliably obtain exclusive locks without worrying about cleanup etc  There are examples on the man page as to how to use it in a shell script

User · Answer

For shell scripts  I tend to go with the mkdir over flock as it makes the locks more portable   Either way  using set -e isn t enough  That only exits the script if any command fails  Your locks will still be left behind   For proper lock cleanup  you really should set your traps to something like this psuedo code  lifted  simplified and untested but from actively used scripts                                                                                Predefined Global Variables                                                                           TMPDIR  tmp myapp      -d  TMP DIR           amp  amp  mkdir -p  TMP DIR        amp  amp  chmod 700  TMPDIR  LOCK DIR  TMP DIR lock                                                                             Functions                                                                           function mklock         lockdir   LOCK DIR   date   s  N        Private Global  Use Epoch Nano PID        If it can create  LOCK DIR then no other instance is running     if   mkdir  LOCK DIR      then         mkdir    lockdir    create this instance s specific lock in queue         LOCK EXISTS true    Global     else         echo  FATAL  Lock already exists  Another copy is running or manually lock clean up required           exit 1001    Or work out some sleep while execution lock elsewhere     fi    function rmlock            -d    lockdir               amp  amp  echo  WARNING  Lock is missing     lockdir does not exist               rmdir    lockdir     -----------------------------------------------------------------------   Private Signal Traps Functions    2     DANGER  SIGKILL cannot be trapped  So  try not to  kill -9 PID  or            there will be  NO CLEAN UP   You ll have to manually remove            any locks in place   ----------------------------------------------------------------------- function   sig exit          Place your clean up logic here         Remove the LOCK        -n  LOCK EXISTS     amp  amp  rmlock    function   sig int       echo  WARNING  SIGINT caught          exit 1002    function   sig quit       echo  SIGQUIT caught      exit 1003    function   sig term       echo  WARNING  SIGTERM caught          exit 1015                                                                               Main                                                                             Set TRAPs trap   sig exit EXIT      SIGEXIT trap   sig int INT        SIGINT trap   sig quit QUIT      SIGQUIT trap   sig term TERM      SIGTERM  mklock    CODE  exit   No need for cleanup code here being in the   sig exit trap function   Here s what will happen  All traps will produce an exit so the function   sig exit will always happen  barring a SIGKILL  which cleans up your locks   Note  my exit values are not low values  Why  Various batch processing systems make or have expectations of the numbers 0 through 31  Setting them to something else  I can have my scripts and batch streams react accordingly to the previous batch job or script

User · Answer

When targeting a Debian machine I find the lockfile-progs package to be a good solution  procmail also comes with a lockfile tool  However sometimes I am stuck with neither of these   Here s my solution which uses mkdir for atomic-ness and a PID file to detect stale locks  This code is currently in production on a Cygwin setup and works well   To use it simply call exclusive lock require when you need get exclusive access to something  An optional lock name parameter lets you share locks between different scripts  There s also two lower level functions  exclusive lock try and exclusive lock retry  should you need something more complex   function exclusive lock try      lockname         local LOCK NAME    1 - basename  0         LOCK DIR   tmp    LOCK NAME  lock      local LOCK PID FILE    LOCK DIR    LOCK NAME  pid       if   -e   LOCK DIR        then         local LOCK PID   cat   LOCK PID FILE  2 gt   dev null           if     -z   LOCK PID     amp  amp  kill -0   LOCK PID  2 gt   dev null         then               locked by non-dead process             echo     LOCK NAME   lock currently held by PID  LOCK PID              return 1         else               orphaned lock  take it over               echo     gt    LOCK PID FILE    2 gt   dev null  amp  amp  local LOCK PID              fi     fi     if     trap -p EXIT               then           already have an EXIT trap         echo  Cannot get lock  already have an EXIT trap          return 1     fi     if     LOCK PID             amp  amp              umask 077  amp  amp  mkdir   LOCK DIR   amp  amp  umask 177  amp  amp  echo     gt    LOCK PID FILE    2 gt   dev null     then         local LOCK PID   cat   LOCK PID FILE  2 gt   dev null             unable to acquire lock  new process got in first         echo     LOCK NAME   lock currently held by PID  LOCK PID          return 1     fi     trap   bin rm -rf    LOCK DIR    exit   EXIT      return 0   got lock     function exclusive lock retry      lockname   retries   delay         local LOCK NAME   1      local MAX TRIES    2 -5       local DELAY    3 -2        local TRIES 0     local LOCK RETVAL      while     TRIES  -lt   MAX TRIES        do          if     TRIES  -gt 0           then             sleep   DELAY          fi         local TRIES      TRIES   1             if     TRIES  -lt   MAX TRIES            then             exclusive lock try   LOCK NAME   gt   dev null         else             exclusive lock try   LOCK NAME          fi         LOCK RETVAL    PIPESTATUS 0             if     LOCK RETVAL  -eq 0           then             return 0         fi      done      return   LOCK RETVAL      function exclusive lock require      lockname   retries   delay        if   exclusive lock retry          then         exit 1     fi

User · Answer

Here s an implementation that uses a lockfile and echoes a PID into it  This serves as a protection if the process is killed before removing the pidfile   LOCKFILE  tmp lock txt if   -e   LOCKFILE     amp  amp  kill -0  cat   LOCKFILE    then     echo  already running      exit fi    make sure the lockfile is removed when we exit and then claim it trap  rm -f   LOCKFILE   exit  INT TERM EXIT echo     gt    LOCKFILE     do stuff sleep 1000  rm -f   LOCKFILE    The trick here is the kill -0 which doesn t deliver any signal but just checks if a process with the given PID exists   Also the call to trap will ensure that the lockfile is removed even when your process is killed  except kill -9

User · Answer

If flock s limitations  which have already been described elsewhere on this thread  aren t an issue for you  then this should work      bin bash          exit if we are unable to obtain a lock  this would happen if        the script is already running elsewhere       note  -x  exclusive  is the default     flock -n 100    exit        put commands to run here     sleep 100   100 gt  tmp myjob lock

User · Answer

There s a wrapper around the flock 2  system call called  unimaginatively  flock 1   This makes it relatively easy to reliably obtain exclusive locks without worrying about cleanup etc  There are examples on the man page as to how to use it in a shell script

User · Answer

When targeting a Debian machine I find the lockfile-progs package to be a good solution  procmail also comes with a lockfile tool  However sometimes I am stuck with neither of these   Here s my solution which uses mkdir for atomic-ness and a PID file to detect stale locks  This code is currently in production on a Cygwin setup and works well   To use it simply call exclusive lock require when you need get exclusive access to something  An optional lock name parameter lets you share locks between different scripts  There s also two lower level functions  exclusive lock try and exclusive lock retry  should you need something more complex   function exclusive lock try      lockname         local LOCK NAME    1 - basename  0         LOCK DIR   tmp    LOCK NAME  lock      local LOCK PID FILE    LOCK DIR    LOCK NAME  pid       if   -e   LOCK DIR        then         local LOCK PID   cat   LOCK PID FILE  2 gt   dev null           if     -z   LOCK PID     amp  amp  kill -0   LOCK PID  2 gt   dev null         then               locked by non-dead process             echo     LOCK NAME   lock currently held by PID  LOCK PID              return 1         else               orphaned lock  take it over               echo     gt    LOCK PID FILE    2 gt   dev null  amp  amp  local LOCK PID              fi     fi     if     trap -p EXIT               then           already have an EXIT trap         echo  Cannot get lock  already have an EXIT trap          return 1     fi     if     LOCK PID             amp  amp              umask 077  amp  amp  mkdir   LOCK DIR   amp  amp  umask 177  amp  amp  echo     gt    LOCK PID FILE    2 gt   dev null     then         local LOCK PID   cat   LOCK PID FILE  2 gt   dev null             unable to acquire lock  new process got in first         echo     LOCK NAME   lock currently held by PID  LOCK PID          return 1     fi     trap   bin rm -rf    LOCK DIR    exit   EXIT      return 0   got lock     function exclusive lock retry      lockname   retries   delay         local LOCK NAME   1      local MAX TRIES    2 -5       local DELAY    3 -2        local TRIES 0     local LOCK RETVAL      while     TRIES  -lt   MAX TRIES        do          if     TRIES  -gt 0           then             sleep   DELAY          fi         local TRIES      TRIES   1             if     TRIES  -lt   MAX TRIES            then             exclusive lock try   LOCK NAME   gt   dev null         else             exclusive lock try   LOCK NAME          fi         LOCK RETVAL    PIPESTATUS 0             if     LOCK RETVAL  -eq 0           then             return 0         fi      done      return   LOCK RETVAL      function exclusive lock require      lockname   retries   delay        if   exclusive lock retry          then         exit 1     fi

User · Answer

This will work  if your script name is unique      bin bash if     pgrep -c   basename  0   -gt 1    then    echo   basename  0  is already running   exit 0 fi   If the scriptname is not unique  this works on most linux distributions      bin bash exec 9 gt  tmp my lock file if   flock -n 9    then    echo  another instance of this script is already running      exit 1 fi   source  http   mywiki wooledge org BashFAQ 045

User · Answer

You need an atomic operation  like flock  else this will eventually fail   But what to do if flock is not available  Well there is mkdir  That s an atomic operation too  Only one process will result in a successful mkdir  all others will fail   So the code is   if mkdir  var lock  myscript exclusivelock then     do stuff       rmdir  var lock  myscript exclusivelock fi   You need to take care of stale locks else aftr a crash your script will never run again

User · Answer

Quick and dirty      bin sh  if   -f sometempfile     echo  Already running    will now terminate     exit else   touch sometempfile fi    do what you want here    rm sometempfile

User · Answer

Late to the party  using the idea from  Majal  this is my script to start only one instance of emacsclient GUI  With it  I can set shortcutkey to open or jump back to the same emacsclient  I have another script to call emacsclient in terminals when I need it  The use of emacsclient here is just to show a working example  one can choose something else  This approach is quick and good enough for my tiny scripts  Tell me where it is dirty        bin bash    if     pgrep -c   basename  0   -lt 2    then   this works but requires script name to be unique if     pidof -x   0  wc -w   -lt 3    then     echo -e  Starting   basename  0       emacsclient --alternate-editor    -c      else     echo -e   0 is running already  fi

User · Answer

PID and lockfiles are definitely the most reliable   When you attempt to run the program  it can check for the lockfile which and if it exists  it can use ps to see if the process is still running   If it s not  the script can start  updating the PID in the lockfile to its own

User · Answer

You need an atomic operation  like flock  else this will eventually fail   But what to do if flock is not available  Well there is mkdir  That s an atomic operation too  Only one process will result in a successful mkdir  all others will fail   So the code is   if mkdir  var lock  myscript exclusivelock then     do stuff       rmdir  var lock  myscript exclusivelock fi   You need to take care of stale locks else aftr a crash your script will never run again

User · Answer

The semaphoric utility uses flock  as discussed above  e g  by presto8  to implement a counting semaphore  It enables any specific number of concurrent processes you want  We use it to limit the level of concurrency of various queue worker processes   It s like sem but much lighter-weight   Full disclosure  I wrote it after finding the sem was way too heavy for our needs and there wasn t a simple counting semaphore utility available

User · Answer

To make locking reliable you need an atomic operation  Many of the above proposals are not atomic  The proposed lockfile 1  utility looks promising as the man-page mentioned  that its  NFS-resistant   If your OS does not support lockfile 1  and your solution has to work on NFS  you have not many options      NFSv2 has two atomic operations    symlink rename   With NFSv3 the create call is also atomic   Directory operations are NOT atomic under NFSv2 and NFSv3  please refer to the book  NFS Illustrated  by Brent Callaghan  ISBN 0-201-32570-5  Brent is a NFS-veteran at Sun    Knowing this  you can implement spin-locks for files and directories  in shell  not PHP    lock current dir   while   ln -s   lock  do    done   lock a file   while   ln -s   f    f  lock  do    done   unlock current dir  assumption  the running process really acquired the lock    mv lock deleteme  amp  amp  rm deleteme   unlock a file  assumption  the running process really acquired the lock    mv   f  lock   f  deleteme  amp  amp  rm   f  deleteme   Remove is also not atomic  therefore first the rename  which is atomic  and then the remove   For the symlink and rename calls  both filenames have to reside on the same filesystem  My proposal  use only simple filenames  no paths  and put file and lock into the same directory

User · Answer

PID and lockfiles are definitely the most reliable   When you attempt to run the program  it can check for the lockfile which and if it exists  it can use ps to see if the process is still running   If it s not  the script can start  updating the PID in the lockfile to its own

User · Answer

All approaches that test the existence of  lock files  are flawed   Why   Because there is no way to check whether a file exists and create it in a single atomic action   Because of this  there is a race condition that WILL make your attempts at mutual exclusion break   Instead  you need to use mkdir   mkdir creates a directory if it doesn t exist yet  and if it does  it sets an exit code   More importantly  it does all this in a single atomic action making it perfect for this scenario   if   mkdir  tmp myscript lock 2 gt  dev null  then     echo  Myscript is already running    gt  amp 2     exit 1 fi   For all details  see the excellent BashFAQ  http   mywiki wooledge org BashFAQ 045  If you want to take care of stale locks  fuser 1  comes in handy   The only downside here is that the operation takes about a second  so it isn t instant   Here s a function I wrote once that solves the problem using fuser           mutex file     Open a mutual exclusion lock on the file  unless another process already owns one      If the file is already locked by another process  the operation fails    This function defines a lock on a file as having a file descriptor open to the file    This function uses FD 9 to open a lock on the file   To release the lock  close FD 9    exec 9 gt  amp -   mutex         local file  1 pid pids       exec 9 gt  gt   file        pids   fuser -f   file      2 gt  amp - 9 gt  amp -      for pid in  pids  do             pid          amp  amp  continue          exec 9 gt  amp -          return 1   Locked by a pid      done      You can use it in a script like so   mutex  var run myscript lock      echo  Already running    gt  amp 2  exit 1      If you don t care about portability  these solutions should work on pretty much any UNIX box   Linux  fuser 1  offers some additional options and there is also flock 1

User · Answer

You can use GNU Parallel for this as it works as a mutex when called as sem  So  in concrete terms  you can use   sem --id SCRIPTSINGLETON yourScript   If you want a timeout too  use   sem --id SCRIPTSINGLETON --semaphoretimeout -10 yourScript   Timeout of  lt 0 means exit without running script if semaphore is not released within the timeout  timeout of  0 mean run the script anyway   Note that you should give it a name  with --id  else it defaults to the controlling terminal   GNU Parallel is a very simple install on most Linux OSX Unix platforms - it is just a Perl script

User · Answer

why dont we use something like   pgrep -f  cmd     cmd

User · Answer

There s a wrapper around the flock 2  system call called  unimaginatively  flock 1   This makes it relatively easy to reliably obtain exclusive locks without worrying about cleanup etc  There are examples on the man page as to how to use it in a shell script

User · Answer

Here s an implementation that uses a lockfile and echoes a PID into it  This serves as a protection if the process is killed before removing the pidfile   LOCKFILE  tmp lock txt if   -e   LOCKFILE     amp  amp  kill -0  cat   LOCKFILE    then     echo  already running      exit fi    make sure the lockfile is removed when we exit and then claim it trap  rm -f   LOCKFILE   exit  INT TERM EXIT echo     gt    LOCKFILE     do stuff sleep 1000  rm -f   LOCKFILE    The trick here is the kill -0 which doesn t deliver any signal but just checks if a process with the given PID exists   Also the call to trap will ensure that the lockfile is removed even when your process is killed  except kill -9

User · Answer

I have a simple solution based on the file name     bin bash  MY FILENAME  basename   BASH SOURCE    MY PROCESS COUNT   ps a -o pid cmd   grep  MY FILENAME   grep -v grep   grep -v      wc - l   if    MY PROCESS COUNT -ne 0     then   echo found another process   exit 0 if    Follows the code to get the job done

User · Answer

Here is a more elegant  fail-safe  quick  amp  dirty method  combining the answers provided above   Usage   include sh lock functions sh init using sh lock init lock using sh acquire lock check lock using sh check lock unlock using sh remove lock   Script File  sh lock functions sh     bin bash  function sh lock init       sh lock scriptName   basename  0      sh lock dir   tmp   sh lock scriptName  lock   lock directory     sh lock file    sh lock dir  lockPid txt   lock file    function sh acquire lock       if mkdir  sh lock dir 2 gt  dev null  then  check for lock         echo   sh lock scriptName lock acquired successfully   gt  amp 2         touch  sh lock file         echo     gt   sh lock file   set current pid in lockFile         return 0     else         touch  sh lock file         read sh lock lastPID  lt   sh lock file         if     -z   sh lock lastPID  -a -d  proc  sh lock lastPID    then   if lastPID is not null and a process with that pid exists             echo   sh lock scriptName is already running   gt  amp 2             return 1         else             echo   sh lock scriptName stopped during execution  reacquiring lock   gt  amp 2             echo     gt   sh lock file   set current pid in lockFile             return 2         fi     fi     return 0    function sh check lock            -f  sh lock file     amp  amp  echo   sh lock scriptName lock file removed   gt  amp 2  amp  amp  return 1     read sh lock lastPID  lt   sh lock file         sh lock lastPID -ne        amp  amp  echo   sh lock scriptName lock file pid has changed   gt  amp 2   amp  amp  return 2     echo   sh lock scriptName lock still in place   gt  amp 2     return 0    function sh remove lock       rm -r  sh lock dir     Usage example  sh lock usage example sh     bin bash    path to sh lock functions sh   load sh lock functions  sh lock init    exit     sh acquire lock lockStatus        lockStatus -eq 1     amp  amp  exit  lockStatus     lockStatus -eq 2     amp  amp  echo  lock is set  do some resume from crash procedures     monitoring example cnt 0 while sh check lock   loop while lock is in place do     echo   sh scriptName running  pid          sleep 1     let cnt           cnt -gt 5     amp  amp  break done   remove lock when process finished sh remove lock    exit     exit 0   Features   Uses a combination of file  directory and process id to lock to make sure that the process is not already running You can detect if the script stopped before lock removal  eg  process kill  shutdown  error etc   You can check the lock file  and use it to trigger a process shutdown when the lock is missing Verbose  outputs error messages for easier debug

User · Answer

Actually although the answer of bmdhacks is almost good  there is a slight chance the second script to run after first checked the lockfile and before it wrote it  So they both will write the lock file and they will both be running  Here is how to make it work for sure   lockfile  var lock myscript lock  if   set -o noclobber  echo       gt    lockfile   2 gt   dev null   then   trap  rm -f   lockfile   exit     INT TERM EXIT else     or you can decide to skip the  else  part if you want   echo  Another instance is already running   fi   The noclobber option will make sure that redirect command will fail if file already exists  So the redirect command is actually atomic - you write and check the file with one command  You don t need to remove the lockfile at the end of file - it ll be removed by the trap  I hope this helps to people that will read it later   P S  I didn t see that Mikel already answered the question correctly  although he didn t include the trap command to reduce the chance the lock file will be left over after stopping the script with Ctrl-C for example  So this is the complete solution

User · Answer

Some unixes have lockfile which is very similar to the already mentioned flock   From the manpage      lockfile  can  be used to create one   or more semaphore files   If lock-   file can t create all the specified   files  in the specified order    it   waits  sleeptime  defaults to 8    seconds and retries the last file that   didn t succeed   You can specify the   number  of  retries  to  do  until   failure  is  returned    If the number   of retries is -1  default  i e     -r-1  lockfile will retry forever

User · Answer

If flock s limitations  which have already been described elsewhere on this thread  aren t an issue for you  then this should work      bin bash          exit if we are unable to obtain a lock  this would happen if        the script is already running elsewhere       note  -x  exclusive  is the default     flock -n 100    exit        put commands to run here     sleep 100   100 gt  tmp myjob lock

User · Answer

Try something like the below   ab  ps -ef   grep -v grep   grep -wc processname    Then match the variable with 1 using an if loop

User · Answer

Use flock 1  to make an exclusive scoped lock a on file descriptor  This way you can even synchronize different parts of the script      bin bash        Wait for lock on  var lock  myscript exclusivelock  fd 200  for 10 seconds   flock -x -w 10 200    exit 1      Do stuff    200 gt  var lock  myscript exclusivelock   This ensures that code between   and   is run only by one process at a time and that the process doesn   t wait too long for a lock   Caveat  this particular command is a part of util-linux  If you run an operating system other than Linux  it may or may not be available

User · Answer

This I have not found mentioned anywhere  it uses read  I don t exactly know if read is actually atomic but it has served me well so far     it is juicy because it is only bash builtins  this is an in process implementation  you start the locker coprocess and use its i o to manage locks  the same can be done interprocess by just swapping the target i o from the locker file descriptors to a on filesystem file descriptor  exec 3 lt  gt  file  amp  amp  exec 4 lt  file        gives locks locker         locked false     while read l  do         case   l  in             lock                  if  locked  then                     echo false                 else                     locked true                     echo true                 fi                                unlock                  if  locked  then                     locked false                     echo true                 else                     echo false                 fi                                                   echo false                            esac     done      locks lock         local response     echo lock  gt  amp   locker 1       read -ru   locker 0   response      response  amp  amp  return 0    return 1       unlocks unlock         local response     echo unlock  gt  amp   locker 1       read -ru   locker 0   response      response  amp  amp  return 0    return 1

User · Answer

Some unixes have lockfile which is very similar to the already mentioned flock   From the manpage      lockfile  can  be used to create one   or more semaphore files   If lock-   file can t create all the specified   files  in the specified order    it   waits  sleeptime  defaults to 8    seconds and retries the last file that   didn t succeed   You can specify the   number  of  retries  to  do  until   failure  is  returned    If the number   of retries is -1  default  i e     -r-1  lockfile will retry forever

User · Answer

Quick and dirty      bin sh  if   -f sometempfile     echo  Already running    will now terminate     exit else   touch sometempfile fi    do what you want here    rm sometempfile

User · Answer

Another option is to use shell s noclobber option by running set -C   Then  gt  will fail if the file already exists   In brief   set -C lockfile   tmp locktest lock  if echo       gt    lockfile   then     echo  Successfully acquired lock        do work     rm   lockfile       XXX or via trap - see below else     echo  Cannot acquire lock - already locked by   cat   lockfile    fi   This causes the shell to call   open pathname  O CREAT O EXCL    which atomically creates the file or fails if the file already exists     According to a comment on BashFAQ 045  this may fail in ksh88  but it works in all my shells     strace -e trace creat open -f  bin bash  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O LARGEFILE  0666    3    strace -e trace creat open -f  bin zsh  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O NOCTTY O LARGEFILE  0666    3    strace -e trace creat open -f  bin pdksh  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O TRUNC O LARGEFILE  0666    3    strace -e trace creat open -f  bin dash  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O LARGEFILE  0666    3   Interesting that pdksh adds the O TRUNC flag  but obviously it s redundant  either you re creating an empty file  or you re not doing anything     How you do the rm depends on how you want unclean exits to be handled   Delete on clean exit  New runs fail until the issue that caused the unclean exit to be resolved and the lockfile is manually removed     acquire lock   do work  code here may call exit  etc   rm   lockfile    Delete on any exit  New runs succeed provided the script is not already running   trap  rm   lockfile   EXIT

User · Answer

Try something like the below   ab  ps -ef   grep -v grep   grep -wc processname    Then match the variable with 1 using an if loop

User · Answer

Another option is to use shell s noclobber option by running set -C   Then  gt  will fail if the file already exists   In brief   set -C lockfile   tmp locktest lock  if echo       gt    lockfile   then     echo  Successfully acquired lock        do work     rm   lockfile       XXX or via trap - see below else     echo  Cannot acquire lock - already locked by   cat   lockfile    fi   This causes the shell to call   open pathname  O CREAT O EXCL    which atomically creates the file or fails if the file already exists     According to a comment on BashFAQ 045  this may fail in ksh88  but it works in all my shells     strace -e trace creat open -f  bin bash  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O LARGEFILE  0666    3    strace -e trace creat open -f  bin zsh  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O NOCTTY O LARGEFILE  0666    3    strace -e trace creat open -f  bin pdksh  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O TRUNC O LARGEFILE  0666    3    strace -e trace creat open -f  bin dash  home mikel bin testopen 2 gt  amp 1   grep -F testopen lock open   tmp testopen lock   O WRONLY O CREAT O EXCL O LARGEFILE  0666    3   Interesting that pdksh adds the O TRUNC flag  but obviously it s redundant  either you re creating an empty file  or you re not doing anything     How you do the rm depends on how you want unclean exits to be handled   Delete on clean exit  New runs fail until the issue that caused the unclean exit to be resolved and the lockfile is manually removed     acquire lock   do work  code here may call exit  etc   rm   lockfile    Delete on any exit  New runs succeed provided the script is not already running   trap  rm   lockfile   EXIT

User · Answer

I wanted to do away with lockfiles  lockdirs  special locking programs and even pidof since it isn t found on all Linux installations  Also wanted to have the simplest code possible  or at least as few lines as possible   Simplest if statement  in one line   if      ps axf   awk -v pid      1  pid  amp  amp   6     basename  0    print  1        then echo  Already running   exit  fi

User · Answer

The existing answers posted either rely on the CLI utility flock or do not properly secure the lock file   The flock utility is not available on all non-Linux systems  i e  FreeBSD   and does not work properly on NFS   In my early days of system administration and system development  I was told that a safe and relatively portable method of creating a lock file was to create a temp file using mkemp 3  or mkemp 1   write identifying information to the temp file  i e  PID   then hard link the temp file to the lock file   If the link was successful  then you have successfully obtained the lock   When using locks in shell scripts  I typically place an obtain lock   function in a shared profile and then source it from the scripts  Below is an example of my lock function   obtain lock       LOCK    1     LOCKDIR    dirname    LOCK       LOCKFILE    basename    LOCK          create temp lock file   TMPLOCK   mktemp -p    LOCKDIR      LOCKFILE XXXXXX  2 gt   dev null    if test  x  TMPLOCK       x  then      echo  unable to create temporary file with mktemp  1 gt  amp 2      return 1   fi   echo       gt     TMPLOCK        attempt to obtain lock file   ln    TMPLOCK      LOCK   2 gt   dev null   if test    -ne 0 then      rm -f    TMPLOCK        echo  unable to obtain lockfile  1 gt  amp 2      if test -f    LOCK   then         echo  current lock information held by    cat    LOCK     1 gt  amp 2      fi      return 2   fi   rm -f    TMPLOCK      return 0       The following is an example of how to use the lock function      bin sh     path to locking profile sh PROG LOCKFILE   tmp myprog lock   clean up       rm -f    PROG LOCKFILE      obtain lock    PROG LOCKFILE   if test    -ne 0 then    exit 1 fi trap clean up SIGHUP SIGINT SIGTERM    bulk of script  clean up exit 0   end of script   Remember to call clean up at any exit points in your script   I ve used the above in both Linux and FreeBSD environments

User · Answer

if   1 -ne    bin fuser   0  2 gt  dev null   wc -w     then     exit 1 fi

User · Answer

I have a simple solution based on the file name     bin bash  MY FILENAME  basename   BASH SOURCE    MY PROCESS COUNT   ps a -o pid cmd   grep  MY FILENAME   grep -v grep   grep -v      wc - l   if    MY PROCESS COUNT -ne 0     then   echo found another process   exit 0 if    Follows the code to get the job done

User · Answer

Really quick and really dirty  This one-liner on the top of your script will work        pgrep -c   basename    0      -gt 1     amp  amp  exit   Of course  just make sure that your script name is unique

User · Answer

Use flock 1  to make an exclusive scoped lock a on file descriptor  This way you can even synchronize different parts of the script      bin bash        Wait for lock on  var lock  myscript exclusivelock  fd 200  for 10 seconds   flock -x -w 10 200    exit 1      Do stuff    200 gt  var lock  myscript exclusivelock   This ensures that code between   and   is run only by one process at a time and that the process doesn   t wait too long for a lock   Caveat  this particular command is a part of util-linux  If you run an operating system other than Linux  it may or may not be available

User · Answer

Take a look to FLOM  Free LOck Manager  http   sourceforge net projects flom   you can synchronize commands and or scripts using abstract resources that does not need lock files in a filesystem  You can synchronize commands running in different systems without a NAS  Network Attached Storage  like an NFS  Network File System  server   Using the simplest use case  serializing  command1  and  command2  may be as easy as executing   flom -- command1   and  flom -- command2   from two different shell scripts

User · Answer

I use oneliner   the very beginning of script      bin bash  if      pgrep -afc    basename   0     -gt  1      then echo  Another instance of   0  has already been started    amp  amp  exit  fi   the beginning of actual script   It is good to see the presence of process in the memory  no matter what the status of process is   but it does the job for me

User · Answer

There s a wrapper around the flock 2  system call called  unimaginatively  flock 1   This makes it relatively easy to reliably obtain exclusive locks without worrying about cleanup etc  There are examples on the man page as to how to use it in a shell script

User · Answer

Answered a million times already  but another way  without the need for external dependencies   LOCK FILE   var lock   basename   0   pid  trap  rm -f   LOCK FILE   exit  INT TERM EXIT if    -f  LOCK FILE  amp  amp  -d  proc  cat  LOCK FILE      then       Process already exists    exit 1 fi echo     gt   LOCK FILE   Each time it writes the current PID      into the lockfile and on script startup checks if a process is running with the latest PID

User · Answer

An example with flock 1  but without subshell  flock  ed file  tmp foo is never removed  but that doesn t matter as it gets flock   and un-flock  ed      bin bash  exec 9 lt  gt   tmp foo flock -n 9 RET    if     RET -ne 0      then     echo  lock failed  exiting      exit fi   Now we are inside the  critical section  echo  inside lock  sleep 5 exec 9 gt  amp -  close fd 9  and release lock   The part below is outside the critical section  the lock  echo  lock released  sleep 5

User · Answer

Create a lock file in a known location and check for existence on script start  Putting the PID in the file might be helpful if someone s attempting to track down an errant instance that s preventing execution of the script

User · Answer

This will work  if your script name is unique      bin bash if     pgrep -c   basename  0   -gt 1    then    echo   basename  0  is already running   exit 0 fi   If the scriptname is not unique  this works on most linux distributions      bin bash exec 9 gt  tmp my lock file if   flock -n 9    then    echo  another instance of this script is already running      exit 1 fi   source  http   mywiki wooledge org BashFAQ 045

User · Answer

Here s an implementation that uses a lockfile and echoes a PID into it  This serves as a protection if the process is killed before removing the pidfile   LOCKFILE  tmp lock txt if   -e   LOCKFILE     amp  amp  kill -0  cat   LOCKFILE    then     echo  already running      exit fi    make sure the lockfile is removed when we exit and then claim it trap  rm -f   LOCKFILE   exit  INT TERM EXIT echo     gt    LOCKFILE     do stuff sleep 1000  rm -f   LOCKFILE    The trick here is the kill -0 which doesn t deliver any signal but just checks if a process with the given PID exists   Also the call to trap will ensure that the lockfile is removed even when your process is killed  except kill -9

User · Answer

Quick and dirty      bin sh  if   -f sometempfile     echo  Already running    will now terminate     exit else   touch sometempfile fi    do what you want here    rm sometempfile

User · Answer

Really quick and really dirty  This one-liner on the top of your script will work        pgrep -c   basename    0      -gt 1     amp  amp  exit   Of course  just make sure that your script name is unique

User · Answer

The existing answers posted either rely on the CLI utility flock or do not properly secure the lock file   The flock utility is not available on all non-Linux systems  i e  FreeBSD   and does not work properly on NFS   In my early days of system administration and system development  I was told that a safe and relatively portable method of creating a lock file was to create a temp file using mkemp 3  or mkemp 1   write identifying information to the temp file  i e  PID   then hard link the temp file to the lock file   If the link was successful  then you have successfully obtained the lock   When using locks in shell scripts  I typically place an obtain lock   function in a shared profile and then source it from the scripts  Below is an example of my lock function   obtain lock       LOCK    1     LOCKDIR    dirname    LOCK       LOCKFILE    basename    LOCK          create temp lock file   TMPLOCK   mktemp -p    LOCKDIR      LOCKFILE XXXXXX  2 gt   dev null    if test  x  TMPLOCK       x  then      echo  unable to create temporary file with mktemp  1 gt  amp 2      return 1   fi   echo       gt     TMPLOCK        attempt to obtain lock file   ln    TMPLOCK      LOCK   2 gt   dev null   if test    -ne 0 then      rm -f    TMPLOCK        echo  unable to obtain lockfile  1 gt  amp 2      if test -f    LOCK   then         echo  current lock information held by    cat    LOCK     1 gt  amp 2      fi      return 2   fi   rm -f    TMPLOCK      return 0       The following is an example of how to use the lock function      bin sh     path to locking profile sh PROG LOCKFILE   tmp myprog lock   clean up       rm -f    PROG LOCKFILE      obtain lock    PROG LOCKFILE   if test    -ne 0 then    exit 1 fi trap clean up SIGHUP SIGINT SIGTERM    bulk of script  clean up exit 0   end of script   Remember to call clean up at any exit points in your script   I ve used the above in both Linux and FreeBSD environments

User · Answer

I find that bmdhack s solution is the most practical  at least for my use case  Using flock and lockfile rely on removing the lockfile using rm when the script terminates  which can t always be guaranteed  e g   kill -9    I would change one minor thing about bmdhack s solution  It makes a point of removing the lock file  without stating that this is unnecessary for the safe working of this semaphore  His use of kill -0 ensures that an old lockfile for a dead process will simply be ignored over-written   My simplified solution is therefore to simply add the following to the top of your singleton      Test the lock LOCKFILE  tmp singleton lock  if   -e   LOCKFILE     amp  amp  kill -0  cat   LOCKFILE    then     echo  Script already running  bye       exit  fi     Set the lock  echo     gt    LOCKFILE    Of course  this script still has the flaw that processes that are likely to start at the same time have a race hazard  as the lock test and set operations are not a single atomic action  But the proposed solution for this by lhunath to use mkdir has the flaw that a killed script may leave behind the directory  thus preventing other instances from running

User · Answer

Here s an approach that combines atomic directory locking with a check for stale lock via PID and restart if stale  Also  this does not rely on any bashisms      bin dash  SCRIPTNAME   basename  0  LOCKDIR   var lock   SCRIPTNAME   PIDFILE    LOCKDIR  pid   if   mkdir  LOCKDIR 2  dev null then       lock failed  but check for stale one by checking if the PID is really existing     PID   cat  PIDFILE      if   kill -0  PID 2  dev null     then        echo  Removing stale lock of nonexistent PID   PID     2        rm -rf  LOCKDIR        echo  Restarting myself    SCRIPTNAME      2        exec   0           fi     echo   SCRIPTNAME is already running  bailing out    2     exit 1 else       lock successfully acquired  save PID     echo       PIDFILE fi  trap  rm -rf   LOCKDIR   QUIT INT TERM EXIT   echo hello  sleep 30s  echo bye

User · Answer

This one line answer comes from someone related Ask Ubuntu Q amp A        FLOCKER        0     amp  amp  exec env FLOCKER   0  flock -en   0    0                  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

User · Answer

Here s an implementation that uses a lockfile and echoes a PID into it  This serves as a protection if the process is killed before removing the pidfile   LOCKFILE  tmp lock txt if   -e   LOCKFILE     amp  amp  kill -0  cat   LOCKFILE    then     echo  already running      exit fi    make sure the lockfile is removed when we exit and then claim it trap  rm -f   LOCKFILE   exit  INT TERM EXIT echo     gt    LOCKFILE     do stuff sleep 1000  rm -f   LOCKFILE    The trick here is the kill -0 which doesn t deliver any signal but just checks if a process with the given PID exists   Also the call to trap will ensure that the lockfile is removed even when your process is killed  except kill -9

User · Answer

Some unixes have lockfile which is very similar to the already mentioned flock   From the manpage      lockfile  can  be used to create one   or more semaphore files   If lock-   file can t create all the specified   files  in the specified order    it   waits  sleeptime  defaults to 8    seconds and retries the last file that   didn t succeed   You can specify the   number  of  retries  to  do  until   failure  is  returned    If the number   of retries is -1  default  i e     -r-1  lockfile will retry forever

User · Answer

Actually although the answer of bmdhacks is almost good  there is a slight chance the second script to run after first checked the lockfile and before it wrote it  So they both will write the lock file and they will both be running  Here is how to make it work for sure   lockfile  var lock myscript lock  if   set -o noclobber  echo       gt    lockfile   2 gt   dev null   then   trap  rm -f   lockfile   exit     INT TERM EXIT else     or you can decide to skip the  else  part if you want   echo  Another instance is already running   fi   The noclobber option will make sure that redirect command will fail if file already exists  So the redirect command is actually atomic - you write and check the file with one command  You don t need to remove the lockfile at the end of file - it ll be removed by the trap  I hope this helps to people that will read it later   P S  I didn t see that Mikel already answered the question correctly  although he didn t include the trap command to reduce the chance the lock file will be left over after stopping the script with Ctrl-C for example  So this is the complete solution

User · Answer

Create a lock file in a known location and check for existence on script start  Putting the PID in the file might be helpful if someone s attempting to track down an errant instance that s preventing execution of the script

User · Answer

Quick and dirty      bin sh  if   -f sometempfile     echo  Already running    will now terminate     exit else   touch sometempfile fi    do what you want here    rm sometempfile

User · Answer

This I have not found mentioned anywhere  it uses read  I don t exactly know if read is actually atomic but it has served me well so far     it is juicy because it is only bash builtins  this is an in process implementation  you start the locker coprocess and use its i o to manage locks  the same can be done interprocess by just swapping the target i o from the locker file descriptors to a on filesystem file descriptor  exec 3 lt  gt  file  amp  amp  exec 4 lt  file        gives locks locker         locked false     while read l  do         case   l  in             lock                  if  locked  then                     echo false                 else                     locked true                     echo true                 fi                                unlock                  if  locked  then                     locked false                     echo true                 else                     echo false                 fi                                                   echo false                            esac     done      locks lock         local response     echo lock  gt  amp   locker 1       read -ru   locker 0   response      response  amp  amp  return 0    return 1       unlocks unlock         local response     echo unlock  gt  amp   locker 1       read -ru   locker 0   response      response  amp  amp  return 0    return 1

User · Answer

The semaphoric utility uses flock  as discussed above  e g  by presto8  to implement a counting semaphore  It enables any specific number of concurrent processes you want  We use it to limit the level of concurrency of various queue worker processes   It s like sem but much lighter-weight   Full disclosure  I wrote it after finding the sem was way too heavy for our needs and there wasn t a simple counting semaphore utility available

User · Answer

Here s an approach that combines atomic directory locking with a check for stale lock via PID and restart if stale  Also  this does not rely on any bashisms      bin dash  SCRIPTNAME   basename  0  LOCKDIR   var lock   SCRIPTNAME   PIDFILE    LOCKDIR  pid   if   mkdir  LOCKDIR 2  dev null then       lock failed  but check for stale one by checking if the PID is really existing     PID   cat  PIDFILE      if   kill -0  PID 2  dev null     then        echo  Removing stale lock of nonexistent PID   PID     2        rm -rf  LOCKDIR        echo  Restarting myself    SCRIPTNAME      2        exec   0           fi     echo   SCRIPTNAME is already running  bailing out    2     exit 1 else       lock successfully acquired  save PID     echo       PIDFILE fi  trap  rm -rf   LOCKDIR   QUIT INT TERM EXIT   echo hello  sleep 30s  echo bye

User · Answer

I use a simple approach that handles stale lock files   Note that some of the above solutions that store the pid  ignore the fact that the pid can wrap around  So - just checking if there is a valid process with the stored pid is not enough  especially for long running scripts   I use noclobber to make sure only one script can open and write to the lock file at one time  Further  I store enough information to uniquely identify a process in the lockfile  I define the set of data to uniquely identify a process to be pid ppid lstart    When a new script starts up  if it fails to create the lock file  it then verifies that the process that created the lock file is still around  If not  we assume the original process died an ungraceful death  and left a stale lock file  The new script then takes ownership of the lock file  and all is well the world  again   Should work with multiple shells across multiple platforms  Fast  portable and simple      usr bin env sh   Author  rouble  LOCKFILE  var tmp lockfile  customize this line  trap release INT TERM EXIT    Creates a lockfile  Sets global variable  ACQUIRED to true on success       Returns 0 if it is successfully able to create lockfile  acquire          set -C  Shell noclobber option  If file exists   gt  will fail      UUID  ps -eo pid ppid lstart      tail -1      if  echo   UUID   gt    LOCKFILE   2 gt  dev null  then         ACQUIRED  TRUE          return 0     else         if   -e  LOCKFILE    then                We may be dealing with a stale lock file                Bring out the magnifying glass               CURRENT UUID FROM LOCKFILE  cat  LOCKFILE              CURRENT PID FROM LOCKFILE  cat  LOCKFILE   cut -f 1 -d                  CURRENT UUID FROM PS  ps -eo pid ppid lstart  CURRENT PID FROM LOCKFILE   tail -1              if     CURRENT UUID FROM LOCKFILE       CURRENT UUID FROM PS     then                  echo  Script already running with following identification   CURRENT UUID FROM LOCKFILE   gt  amp 2                 return 1             else                   The process that created this lock file died an ungraceful death                     Take ownership of the lock file                  echo  The process  CURRENT UUID FROM LOCKFILE is no longer around  Taking ownership of  LOCKFILE                  release  FORCE                  if  echo   UUID   gt    LOCKFILE   2 gt  dev null  then                     ACQUIRED  TRUE                      return 0                 else                     echo  Cannot write to  LOCKFILE  Error    gt  amp 2                     return 1                 fi             fi         else             echo  Do you have write permissons to  LOCKFILE     gt  amp 2             return 1         fi     fi      Removes the lock file only if this script created it   ACQUIRED is set      OR  if we are removing a stale lock file  first parameter is  FORCE    release           Destroy lock file  Take no prisoners      if     ACQUIRED           1      FORCE     then         rm -f  LOCKFILE     fi      Test code   int main  int argc  const char  argv     echo  Acquring lock   acquire if      -eq 0    then      echo  Acquired lock       read -p  Press  Enter  key to release lock         release     echo  Released lock   else     echo  Unable to acquire lock   fi

User · Answer

Some unixes have lockfile which is very similar to the already mentioned flock   From the manpage      lockfile  can  be used to create one   or more semaphore files   If lock-   file can t create all the specified   files  in the specified order    it   waits  sleeptime  defaults to 8    seconds and retries the last file that   didn t succeed   You can specify the   number  of  retries  to  do  until   failure  is  returned    If the number   of retries is -1  default  i e     -r-1  lockfile will retry forever

[bash] Quick-and-dirty way to ensure only one instance of a shell script is running at a time

Examples related to bash

Examples related to shell

Examples related to process

Examples related to lockfile