How to use mutex lock and unluck in different functions

I have multiple functions that get executed in a row.
The first function determines a pointer to a location in ram and in case the location is shared with another thread it calls the lock function of mutex.
The second function processes the data pointed to by the pointer and afterwards I unlock the ressource. As soon as the programm executes mtx.lock() it gets stuck so the programm just stops proceeding. I'm emulating a cpu and a simple graphicschip and I try to lock memory locations which get accessed by both (THe cpu and "gpu" run on different threads). I am trying to prevent simultaneous access to the locations in memory which are accessed by both threads mentioned above.
I have a mutex for each of those addresses or address ranges in the virtual memory(array). Currently only the "cpu" thread locks the mutex, they are not implemented yet for the gpu, so they can't be locked when the "cpu" executes the lock function the first time.

More precisely, the "cpu" runs on a seperate thread and the "gpu" with display output runs on the main thread. I don't call thread_cpu.join(), in case this is the error (where thread_cpu is initialized like std::thread thread_cpu(cpu.run());).

My code looks like this:

sync.h (included in multiple cpp files)

inline std::mutex mtx;

memory.cpp (returns the pointer and locks the mutex, after the processing with the pointer the mutex gets unlocked by post_process)

#include "sync.h"

class Memory{
private:
     UInt32* virtual_memory;

public:
     Memory(){
          virtual_memory = new UInt32[0x2000];
     };

     UInt32* get_address(UInt32 addr_virt){
          mtx.lock();
          return &virtual_memory[addr_virt];
     }

     void post_process(){
          mtx.unlock();
     }
}

In reality it's more complex but this shows how the mutex is implemented. how could one achieve this functionality?

I'd (strongly) advise starting with a simple, general rule: don't directly lock or unlock a mutex.

Instead, make it a practice to lock the mutex with something like std::lock_guard (or std::scoped_lock or std::unique_lock depending on the situation) that unlocks the mutex automatically when leaving the scope in which you locked it.

For example:

     UInt32* get_address(UInt32 addr_virt){
          std::lock_guard L(mtx);
          return &virtual_memory[addr_virt];
     }

If you need to call multiple functions that expect the mutex to be owned throughout, create a function that locks the mutex, and then calls the functions in the prescribed order:

void foo() { 
    std::lock_guard L(mtx);
    a(); // none of a(), b() or c() deals with the mutex at all.
    b();
    c();
}

And no, you can't lock a mutex in one thread, then do the matching unlock from another thread. When one thread locks a mutex, that same thread needs to unlock the mutex. The whole point of a mutex is to ensure that only one thread can access the shared resource while the mutex is locked. If one thread locked the mutex, and another unlocked it, that would subvert the whole purpose of having a mutex to start with.