Is there any mutex/semaphore mechanism in shell scripts?

I'm looking for mutex/semaphore/concurrency mechanism in shell script. Consider following situation: Unless "a" user does not close the shared file, "b" user should not able to open/update it. I'm just wondering how to im开发者_高级运维plement mutex, semaphore, critical sections, etc. in shell scripting.

Which is the easiest way to implement locking mechanism [file level] in shell scripting?

The BashFAQ noted by shellter has some good examples. The basic idea, which I'm moving here so the page is self-contained, is to use an operation that both tests and sets at the same time: mkdir

mkdir will fail if the directory exists and will make it if it does not. It's an atomic operation and you can use it like so to do a mutex in your shell script (from the above BashFAQ)

# Bourne
lockdir=/tmp/myscript.lock
if mkdir "$lockdir"
then    # directory did not exist, but was created successfully
    echo >&2 "successfully acquired lock: $lockdir"
    # continue script
else    # failed to create the directory, presumably because it already exists
  echo >&2 "cannot acquire lock, giving up on $lockdir"
  exit 0
fi

follow the link for more detail on cleanup and other items.

See BashFAQ and ProcessManagment for discussions on file locking in Bash.

Tagging your question as shell (only) limits the number of people that can help you. You may want to add unix, ksh, bash.

There are numerous questions/answers on this topic posted here already on S.O.

I hope this helps.

You can use the flock utility to lock a file / use it as a mutex.

Example:

#!/bin/sh -eu
#advanced bash stuff not needed
: >> lock #create a file if it doesn't exist
{
flock 3 #lock file by filedescriptor

echo $$ working with lock
sleep 2
echo $$ done with lock

} 3<lock

Example usage:

./mx & ./mx & ./mx & #will run one at a time cuz of the lock

(

In reply to massimo's point:

If you don't want to hardcode a filedecriptor number (it should rarely be a problem if you aren't hardcoding 0, 1, or 2, but anyway), then in bash (but not in a POSIX only shell) you can have the system pick a fd for you with:

{
flock $fd
#...
} {fd}<lock

)

You will want to prevent constant polling, and use an interruption like mechanism instead.

For that use a file in memory (run directory), and wait it to be changed by another process:

mutex="/run/user/$(id -u)/mutex"

waitMutex () {
    tail --follow --lines=0 "${mutex}" |
    head -n1 >/dev/null
    echo > "${mutex}"
}

I needed a mutex for a bash function, and I am doing

mkdir /tmp/nice_exit || return 0

At the beginning of the function and then at the end of the function, I am doing

rm -rf /tmp/nice_exit