Prevent concurrent usage and deallocation - c++

Question

Given the following C-API internally implemented in C++
struct OpaqueObject;
struct OpaqueObject *allocateObject();
int deallocateObject(struct OpaqueObject *obj);
int useObject(struct OpaqueObject *obj);
It is safe to allocate, use and deallocate several distinct struct OpaqueObject-Instances concurrently. Of course, the concurrent usage of one struct OpaqueObject-Instance is not allowed and would yield undefined behavior. As a safeguard, the struct OpaqueObject contains a mutex, prohibiting exactly this situation: The function useObject() returns with an error code, if several threads try to call it with the same struct OpaqueObject-Instance.
struct OpaqueObject {
std::mutex access;
// ...
};
int useObject(struct OpaqueObject *obj) {
if (!obj->access.try_lock()) {
// different thread currently uses this obj
return CONCURRENT_USE_ERROR;
} else {
// start using this obj
// ...
obj->access.unlock();
return OK;
}
}
But how can this safeguard mechanism extended to the function deallocateObject()? The first naive approach would be
int deallocateObject(struct OpaqueObject *obj) {
if (!obj->access.try_lock()) {
// different thread currently uses this obj
return CONCURRENT_USE_ERROR;
} else {
delete obj; // <--- (1)
return OK;
}
}
But it's undefined behavior to destroy a mutex when it's still locked. We can't simply unlock it right before line (1), since this would completely foil our efforts to prevent concurrent usage and deallocation.
Is it possible to return with an error in either useObject() or deallocateObject(), if these functions were used concurrently with the same struct OpaqueObject-Instance?

Answer 1

You could exchange the std::mutex with a std::atomic<int>:
struct OpaqueObject {
std::atomic<int> access = 0;
// ...
};
And then in your functions you could atomically exchange the values and see if it is in use:
int useObject(struct OpaqueObject *obj) {
if (obj->access.exchange(1)) {
// different thread currently uses this obj
return CONCURRENT_USE_ERROR;
} else {
// start using this obj
// ...
obj->access.exchange(0);
return OK;
}
}
If the object is in use variable access = 1 and std::atomic::exchange will return 1. Otherwise it returns 0 and sets access to 1.
Also deleting the object would work.
int deallocateObject(struct OpaqueObject *obj) {
if (obj->access.exchange(1)) { // (*)
// different thread currently uses this obj
return CONCURRENT_USE_ERROR;
} else {
delete obj; // (**)
return OK;
}
}
Important: Have you considered what happen's after you have deleted the object? How do you notify other threads about it's deletion?