Is class static method thread safe?

class MyClass
{
public:
	static int DoSomething()
	{
		int retval = 0;
		pthread_mutex_lock(&m_mutex);
		//here is the code to do a very short cpu work
		retval = result;
		pthread_mutex_unlock(&m_mutex);
		
		return retval;
	}
private:
	static pthread_mutex_t m_mutex;
};

void* worker_thread(void* param)
{
	int retval = DoSomething();
	pthread_exit((void*)0);
}

Is the class static method DoSomething thread safe?

it depends on //here is the code to do a very short cpu work

if
//here is the code to do a very short cpu work
shares data that is access from other locations and that is not proteced, than possible not
if it does share nothing than there is nothing to prodect

btw
if
//here is the code to do a very short cpu work
throws an exception that you do not handle than your mutex will never be unlocked

with other words: //here is the code to do a very short cpu work: you can call/use only another thread safe class/function/method/construct
also you need to link thread safe libs, otherwise it won't work

Oh, thread safe is such a headache thing. Gurus, Can you give me some good links about thread safe topic? Thanks in advance.

I do not know what do you really mean by that
https://www.linuxquestions.org/quest...d-safe-317273/
https://en.wikipedia.org/wiki/Thread_safety

Threads are much "cheaper" than processes and also threads can much more easily communicate with each other (than processes).

Let's assume that you are talking about threads, not processes.

The mere fact that something is a "static method" really doesn't mean anything at all. Pragmatically, contention and conflict among multiple threads must be prevented. Typically, this is done in the fundamental design of the processes themselves, not by the classes etc. which they use. You have to know where threads could possibly "race" with one another, and take appropriate steps in your design to prevent those races.

I'm waving my hands at this point because the topic just got very large. However, the immediate answer to your immediate question is: N-o.

The best way to make anything thread-safe is to avoid them like the plague.
IMHO