Mutex blocking the thread in a producer-consumer problem

I have a fundamental question regarding the producer consumer problem. Please consider the below pseudo-code.

//  Consumer. This is in the thread I created for asynchronous log writing     
//  so that I don't block the important threads with my silly log-writing 
//  operation

run()
{
    mutex.lock();  // Line A
    retrieveFromQueueAndWriteToFile();
    mutex.unlock();   
}

//  producer. This function gets log messages from 'x' number of threads
add( string mylog )
{
    mutex.lock();  // Line B, consider internal call to pthread_mutex_lock 
    Queue.push(mylog);
    mutex.lock();  
}

When the log writing operation is in progress in the consumer function the mutex lock is held there. So, when a new log comes in, at Line B, the mutex lock cannot be obtained in the add function. This blocks the important threads when log writing operation is happening.

Is this not the same as writing the log to the file with the other important threads itself. I don't see the point in creating a new thread to write the logs to a file when the important threads are being blocked anyways.
Any help appreciated.

Solution

You can split retrieveFromQueueAndWriteToFile to: retrieveFromQueue and writeLogToFile. Something like this:

run()
{
    mutex.lock();  // Line A
    auto log = retrieveFromQueue();
    mutex.unlock();

    writeLogToFile(log); // this operation does not need a lock

}

Note: If run is called only by one thread in an infinite loop, only the push and pop from the queue are locked, the write to file part of the operation is done by that thread without locking.