Question

Today I came across this piece of code

internal  object UpdatePracownik(object employee)
{  
    lock (employee)
    {
        // rest of the code 
    }

    return employee;
}

I was wondering if this is valid solution for locking access to function?

Wouldn’t be better to use attribute

[MethodImpl(MethodImplOptions.Synchronized)] 

instead of this kind of lock ?

Answer 1

Well it depends. If all threads call this method by passing the same globally visible object as parameter then they will all see the same lock and there will be no problems.

If instead each thread will call this method by passing its own object then locking is useless because they all see different locks. We must know the context in which the method is called to see if this is safe or not.

Using the synchronization method proposed by you makes the entire method body be wrapped in a lock(this) statement like:

internal  object UpdatePracownik(object employee)
{
    lock (this)
    {
        // code        
    }
}

which will guarantee atomicity of execution by multiple threads but may be too coarse-grain for your purposes and is generally not advisable.