Boost interprocess lock_file does not work between two processes

Question

I am trying to use boost file_lock to control two processes. I have process 1 obtaining a lock and then sleeping:

#include <boost/interprocess/sync/file_lock.hpp>
#include <fstream>
#include <chrono>
#include <thread>

int main()
{
    std::string lock_path = "lockfile";
    std::ofstream stream(lock_path, std::ios::app);
    boost::interprocess::file_lock lock(lock_path.c_str());
    if (lock.try_lock())
    {
        std::this_thread::sleep_for(std::chrono::seconds(30));
    }

    return 0;
}

while this process is sleeping, I will run a second process which tries to obtain the lock as well.

#include <boost/interprocess/sync/file_lock.hpp>
#include <iostream>

int main()
{
    boost::interprocess::file_lock lock("lockfile");
    if (lock.try_lock())
    {
        std::cout << "got here" << std::endl;
    }
    return 0;
}

I am expecting the cout statement on the second process not to print because the file is already locked by another process but it does print. What am I missing here? is file_lock not supposed to be used this way?

The programs work as expected for me (Linux), but opening the file _after_ having gotten the lock seems more reasonable — Ted Lyngmo, Feb 06 '23 at 23:40
What is your OS and are you sure you use the same lock file for both processes? — Evg, Feb 06 '23 at 23:47
I am on Linux and yes I am using the same lock file for both processes. — hbnoory, Feb 06 '23 at 23:48
@TedLyngmo so when you run the second process while the first one is sleeping, the cout doesn't print anything? — hbnoory, Feb 07 '23 at 00:26
@hbnoory Exactly. The second program terminates directly without printing anything. — Ted Lyngmo, Feb 07 '23 at 00:27

score 1 · Accepted Answer · answered Feb 07 '23 at 00:55

The best explanation I can think of is when your processes accidentally refer to different files. This might occur when

the current working directories are not the same
the processes run in isolated environments altogether (e.g. dockerized)
the file has been deleted/recreated in the meantime (meaning the inode doesn't match, even though the filename does)

Here's a simplified program that can serve as both parties:

Live On Coliru

#include <fstream>
#include <iostream>
#include <thread>

#include <boost/static_assert.hpp>
#include <boost/interprocess/sync/file_lock.hpp>

namespace bip = boost::interprocess;
using namespace std::chrono_literals;
static inline auto constexpr lock_path = "lockfile";

int main() {
    bip::file_lock lock(lock_path);
    if (lock.try_lock()) {
        std::ofstream stream(lock_path, std::ios::app);
        std::cout << "got lock" << std::endl;
        std::this_thread::sleep_for(2s);
    }
    std::cout << "bye" << std::endl;
}

Local demo:

Boost interprocess lock_file does not work between two processes

1 Answers1