为什么lock_guard可以通过unique_lock获得一个已经锁定的互斥锁?-仍然有问题

我正在研究这个例子。我找到了这个问题，并以为我会得到答案，但我仍然有一个问题。

为了方便，我把代码贴在这里:

std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;
void worker_thread()
{
    // Wait until main() sends data
    std::cout << "------------------------n";
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, []{return ready;});
    // after the wait, we own the lock.
    std::cout << "Worker thread is processing datan";
    data += " after processing";
    // Send data back to main()
    processed = true;
    std::cout << "Worker thread signals data processing completedn";
    // Manual unlocking is done before notifying, to avoid waking up
    // the waiting thread only to block again (see notify_one for details)
    lk.unlock();
    cv.notify_one();
}
int main()
{
    std::thread worker(worker_thread);
    data = "Example data";
    // send data to the worker thread
    {
        std::lock_guard<std::mutex> lk(m);
        ready = true;
        std::cout << "main() signals data ready for processingn";
    }
    cv.notify_one();
    // wait for the worker
    {
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, []{return processed;});
    }
    std::cout << "Back in main(), data = " << data << 'n';
    worker.join();
    return 0;
}

语句std::unique_lock<std::mutex> lk(m);不应该阻塞主线程，因为互斥体m被worker_thread锁定?如果是，在这个例子中，它后面的语句cv.wait(lk, []{return processed;});不是不必要的吗?当主线程可以锁定互斥锁时，processed已经为true。