Modify shared state and notify std::condition_variable if std::mutex::lock throws

I encountered some problem and I'm not sure how to deal with it.

#include <iostream>
#include <thread>
#include <condition_variable>
#include <chrono>

std::condition_variable CV;
std::mutex m;
std::size_t i{0};

void set_value() try
{
    std::this_thread::sleep_for(std::chrono::seconds{2});
    {
        std::lock_guard<std::mutex> lock{m};
        i = 20;
    }
    CV.notify_one();
}
catch(...){
    //what to do?
}

int main()
{
    std::thread t{set_value};
    t.detach();

    std::unique_lock<std::mutex> lock{m};
    CV.wait(lock, []{ return i != 0; });

    std::cout << "i has changed to " << i << std::endl; 
}

This of course works fine but how should I handle the case when std::lock_guard::lock throws an exception?

At first I was thinking to create global std::atomic<bool> mutex_lock_throwed{ false }; that I could set to true inside the catch block. Than I could notify_one()

catch(...){
    mutex_lock_throwed.store(true);
    CV.notify_one();
}

and change predicate for wait function to

[]{ return i != 0 || mutex_lock_throwed.load(); }

This actually worked very well but I read this in cppreference

Even if the shared variable is atomic, it must be modified under the mutex in order to correctly publish the modification to the waiting thread.

As you can see its not possible if mutex throws. So what should be the correct way to handle this?