C++文件操作如何加锁？Boost文件锁与自封装方案对比

void flockfile(FILE *filehandle);  //阻塞锁定文件，确保线程访问互斥，增加锁定计数
int ftrylockfile(FILE *filehandle);//非阻塞锁定文件，尝试锁定，不成功不作任何操作
void funlockfile(FILE *filehandle);//释放文件锁定并减少计数

 namespace fs = std::filesystem;
 const fs::path lDir = "test.lock";

 // 尝试获取锁
 if (fs::create_directory(lDir)) {
     // 获取锁
     // 具体操作
     // 释放锁
     fs::remove(lDir);
 } else {
     // 异常情况
 }

#define _POSIX_C_SOURCE 200809L

#include <sys/types.h>

#include <fcntl.h>
#include <unistd.h>

#include <atomic>
#include <cerrno>
#include <chrono>
#include <cstdio>
#include <stdexcept>
#include <string>
#include <system_error>
#include <thread>
#include <vector>


void writeUnlocked(FILE* stream, const std::string& text)
{
    for (unsigned char ch : text) {
        if (::putc_unlocked(ch, stream) == EOF) {
            throw std::runtime_error("putc_unlocked failed");
        }
    }
}

void blockingStdioLockExample(FILE* stream)
{
    ::flockfile(stream);

    try {
        writeUnlocked(
            stream,
            "call flockfile-funlockfile\n"
        );
        writeUnlocked(
            stream,
            "operate the same lock\n"
        );
    } catch (...) {
        ::funlockfile(stream);
        throw;
    }

    ::funlockfile(stream);
}

void tryStdioLockExample(FILE* stream)
{
    std::atomic<bool> workerHasLock{false};

    std::thread worker([&] {
        ::flockfile(stream);
        workerHasLock.store(true, std::memory_order_release);

        writeUnlocked(
            stream,
            "thread get lock,keep 500ms\n"
        );

        std::this_thread::sleep_for(
            std::chrono::milliseconds(500)
        );

        writeUnlocked(
            stream,
            "thread release lock\n"
        );
        ::funlockfile(stream);
    });


    while (!workerHasLock.load(std::memory_order_acquire)) {
        std::this_thread::yield();
    }

    if (::ftrylockfile(stream) == 0) {
        writeUnlocked(
            stream,
            " ftrylockfile() success\n"
        );

        ::funlockfile(stream);
    } else {
        std::fprintf(
            stderr,
            "ftrylockfile() err："
            "other thread keep lock\n"
        );
    }

    worker.join();

    if (::ftrylockfile(stream) == 0) {
        writeUnlocked(
            stream,
            "other thead exit，ftrylockfile() ok\n"
        );
        ::funlockfile(stream);
    }
}

void stdioWriter(FILE* stream, int threadId)
{
    for (int index = 0; index < 5; ++index) {
        const std::string line =
            "thread=" + std::to_string(threadId) +
            ", index=" + std::to_string(index) + "\n";

        ::flockfile(stream);
        writeUnlocked(stream, line);
        ::funlockfile(stream);
    }
}

void runStdioLockDemo()
{
    const char* path = "stdio_lock_output.txt";

    FILE* stream = std::fopen(path, "w");
    if (stream == nullptr) {
        throw std::system_error(
            errno,
            std::generic_category(),
            "fopen"
        );
    }

    try {
        blockingStdioLockExample(stream);
        tryStdioLockExample(stream);

        ::flockfile(stream);
        writeUnlocked(
            stream,
            "flockfile demo\n"
        );
        ::funlockfile(stream);

        std::vector<std::thread> threads;
        for (int id = 0; id < 4; ++id) {
            threads.emplace_back(stdioWriter, stream, id);
        }

        for (std::thread& thread : threads) {
            thread.join();
        }

        if (std::fflush(stream) != 0) {
            throw std::system_error(
                errno,
                std::generic_category(),
                "fflush"
            );
        }
    } catch (...) {
        std::fclose(stream);
        throw;
    }

    if (std::fclose(stream) != 0) {
        throw std::system_error(
            errno,
            std::generic_category(),
            "fclose"
        );
    }

    std::printf("FILE* streamlock output：%s\n", path);
}

int main()
{
    runStdioLockDemo();

    return 0;
}