当std :: lock_guard仍然在作用域内时，使用pthread_create创建线程是否安全？

Question

I have a function like following in which threads acquire a lock by using std::lock_guard mutex and write to the file via ofstream .

When the current file size increases the max size, then I want to create an independent thread that should compress the file and should terminate.

I want to understand the implications of calling pthread_create when std::lock_guard is still in scope.

Is it safe? Will the lock be applied to the new thread (I don't intend it to be so) as well?

void log (std::string message)
{
    std::lock_guard<std::mutex> lck(mtx);

    _outputFile << message << std::endl;
    _outputFile.flush();
    _sequence_number++;
    _curr_file_size = _outputFile.tellp();

    if (_curr_file_size >= max_size) {
        char *lf = strdup(_logfile.c_str());
        // Create an independent thread to compress the file since
        // it takes some time to compress huge files.
        if (!_compress_thread) {
            pthread_create(&_compress_thread, NULL, compress_log, (void *)lf);
        }
    }
}

void * compress_log (void *arg) 
{
    pthread_detach(pthread_self());

    // Code to compress the file
    // ...

   { // Create a scope for lock_gaurd

       std::lock_guard<std::mutex> lck(mtx);
       _compress_thread = NULL;
   }
   pthread_exit(NULL);
}

Answer 1

A mutex works at thread level, it only affects the thread that uses it. When a thread locks a mutex, two things can happen:

1. A mutex is unlocked - it becomes locked and the thread execution continues.
2. A mutex is already locked - the thread does not continue, but waits until the mutex becomes unlocked.

Your new thread runs the compress_log() function, which does not access the mutex at all. Consequently, it will run regardless of whether the mutex is locked or not (the mutex in your case will unlock when log() exits).

---

An unrelated advise: use std::thread instead of pthread_create , this way your application becomes more portable:

    std::thread{ [lf] { compress_log(lf); } }.detach();