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 implement mutex, semaphore, critical sections, etc. in shell scripting.
Which is the easiest way to implement locking mechanism [file level] in shell scripting?
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