class PhusionPassenger::DaemonController::LockFile

same filename is not enough.
threads if the different threads use the same LockFile object. Specifying the
Note that on JRuby, LockFile can only guarantee synchronization between
trying to obtain a shared lock or an exclusive lock.
exclusive lock, then no other processes can lock the file, whether they’re
exclusive lock has been obtained by a process. If a process has obtained an
for multiple processes to obtain a shared lock on a file as long as no
Processes can obtain either a shared lock or an exclusive lock. It’s possible
within a single process).
inter-process synchronization (as opposed to only inter-thread synchronization
A lock file is a synchronization mechanism, like a Mutex, but it also allows

def exclusive_lock

exception will be raised.
The lock file *must* be writable, otherwise an Errno::EACCESS

block until the lock file has been unlocked.
shared or exclusively) by another process/thread then this method will
then unlock the lockfile. If the lock file was already locked (whether
Obtain an exclusive lock on the lock file, yield the given block, 
def exclusive_lock
  File.open(@filename, 'w') do |f|
    if Fcntl.const_defined? :F_SETFD
      f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
    end
    f.flock(File::LOCK_EX)
    yield
  end
end

def initialize(filename)

depends on the current working directory.
is a relative filename, then the actual lock file that will be used
Note that LockFile will use this exact filename. So if +filename+

file will not be created until one's trying to obtain a lock.
+filename+ may point to a nonexistant file. In that case, the lock

Create a LockFile object. The lock file is initially not locked. 
def initialize(filename)
  @filename = filename
end

def shared_lock

exception will be raised.
The lock file *must* be writable, otherwise an Errno::EACCESS

block if only shared locks have been obtained.
block until the exclusive lock has been released. This method will not
locked by another process/thread then this method will
then unlock the lockfile. If the lock file was already exclusively
Obtain an exclusive lock on the lock file, yield the given block, 
def shared_lock
  File.open(@filename, 'w+') do |f|
    if Fcntl.const_defined? :F_SETFD
      f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
    end
    f.flock(File::LOCK_SH)
    yield
  end
end

def try_exclusive_lock

If a lock can be obtained, then the given block will be yielded.

no lock can be obtained, instead of blocking.
But unlike #exclusive_lock, this method will raise AlreadyLocked if
Try to obtain an exclusive lock on the lock file, similar to #exclusive_lock. 
def try_exclusive_lock
  File.open(@filename, 'w') do |f|
    if Fcntl.const_defined? :F_SETFD
      f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
    end
    if f.flock(File::LOCK_EX | File::LOCK_NB)
      yield
    else
      raise AlreadyLocked
    end
  end
end

def try_shared_lock

If a lock can be obtained, then the given block will be yielded.

no lock can be obtained, instead of blocking.
But unlike #shared_lock, this method will raise AlreadyLocked if
Try to obtain a shared lock on the lock file, similar to #shared_lock. 
def try_shared_lock
  File.open(@filename, 'w+') do |f|
    if Fcntl.const_defined? :F_SETFD
      f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
    end
    if f.flock(File::LOCK_SH | File::LOCK_NB)
      yield
    else
      raise AlreadyLocked
    end
  end
end