在销毁对象之前对其进行互斥锁定会释放内存或其他意外情况

Question

Is it a good and safe practice to lock mutex of the c++ object before delete this object (without unlocking) ? I do this to protect possible using of object at this milliseconds from other thread (very low probability).

Will the memory unallocated after that? Is it a good practice?

Example:

    ptr_to_delete->MUTEX.lock_writing(); // can not delete session if its already locked. (additational protection)
    ptr_to_delete->cleanup();
    delete ptr_to_delete;

Answer 1

"I do this to protect possible using of object at this milliseconds from other thread". In this instance, it doesn't really matter if the object's mutex is locked or not - if you've deleted the object in one thread and other threads still have a pointer to it which may be used, you're going to run into trouble.

EDIT :

It's still problematic. As piokuc said, you need to be releasing and freeing the mutex at some point, otherwise your program will be leaking.

There's still the situation where a worker thread and the cleaning thread can obtain a pointer to the object simultaneously. If the cleaning thread deletes the object before the worker thread uses it, you will get undefined behaviour (ie a crash).

You should create an accessor function for your array of pointers that only returns a pointer if it's not locked (and locks it before returning). That way, only one thread at a time may have the pointer, and there is no chance of a worker thread obtaining/using a pointer that has been deleted by your cleaning thread.

Answer 2

Pthreads doesn't have a lock_writing function, so it's not possible to review your code without knowing what that does.

However it is undefined behavior to call pthread_mutex_destroy on a mutex that is locked. So, assuming that the destructor of the object does destroy its mutex (either explicitly or as part of the destructor of a data member), you must unlock the mutex before that happens.

If you unlock it in the correct place then your code is correct. If you unlock it in the wrong place then it's incorrect. I can't tell you exactly where the correct place is.

Other thread can get pointer to object from array at the same time when other thread can get it to delete from array and memory. "Work" thread will always get pointer, then lock mutex, make some work then unlock mutex and loss pointer forever.

Possibly you need a mutex to protect the whole data structure, not just one object in it. It seems to me there is a possible race condition:

Thread 1                                Thread 2
                                    get pointer to object from data structure
get ptr from data structure
lock object
cleanup
unlock object
destroy object
                                    lock object (oops, it doesn't exist any more)