수동 잠금과 동기화 방법의 차이점

수동 잠금과 동기화 방법의 차이점

---

이것 사이에 차이점이 있습니까?

internal class MyClass
{
    private readonly object _syncRoot = new Object();

    public void DoSomething() 
    {
        lock(_syncRoot)
        {
            ...
        }
    }

    public void DoSomethingElse() 
    {
        lock(_syncRoot)
        {
            ...
        }
    }
}

이:

internal class MyClass
{
    [MethodImpl(MethodImplOptions.Synchronized)]
    public void DoSomething() 
    {
        ...
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    public void DoSomethingElse() 
    {
        ...
    }
}

내가 보는 유일한 차이점은 첫 번째 접근 방식은 일부 개인 멤버를 잠그는 반면 두 번째 접근 방식은 인스턴스 자체를 잠급니다 (따라서 인스턴스의 다른 모든 것을 잠 가야 함). 사용하는 방법에 대한 일반적인 조언이 있습니까? 나는 현재 우리 프로젝트에서 서로 다른 접근 방식으로 작성된 비슷한 목적을 가진 두 개의 클래스를 발견했습니다.

편집하다:

한 가지 더 질문이있을 것입니다. 이것은 :

internal class MyClass
{
    [MethodImpl(MethodImplOptions.Synchronized)]
    public void DoSomething() 
    {
        ...
    }
}

정확히 다음과 같습니다.

internal class MyClass
{
    public void DoSomething() 
    {
        lock(this) 
        {
            ...
        }
    }
}

---

첫 번째 방법은 _syncRoot를 비공개로 만들 수 있기 때문에 선호됩니다. 이것은 교착 상태의 위험을 낮 춥니 다.

이것은 MethodImplOptions.Synchronized결국 그렇게 좋지 않은 것으로 판명 된 초기의 야심 찬 아이디어에서 남은 것입니다.

Regarding the last question: Yes, according to this blog they are functionally equivalent (but not implemented the same way). And all forms of lock(this) are discouraged, again because of deadlock scenarios.

---

check out http://blogs.msdn.com/b/bclteam/archive/2004/01/20/60719.aspx and http://www.experts-exchange.com/Programming/Languages/C_Sharp/Q_20926988.html
They discuss about lock(this) too and discourage using it since:

completely unrelated code can choose to lock on that object as well

Quoting from EE:

If you lock an object, all other threads that need to access THIS PARTICULAR OBJECT will wait, until the other object finishes. However if you mark a method as Synchronized, THIS PARTICULAR METHOD will not be executed at more than one thread. Lock secures the object, Synchronized secures the method.

---

Just having a quick look and found that portable devices do not support MethodImplOptions.Synchronized.

There is also a remark:

Locking on the instance or on the type, as with the Synchronized flag, is not recommended for public types, because code other than your own can take locks on public types and instances. This might cause deadlocks or other synchronization problems.

source: http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.methodimploptions%28v=VS.100%29.aspx

---

I think the difference would depend on what objects are being referenced in the decorated methods. From what I've read, the decoration actually implements lock() in IL.

The best approach would be to do the most specific locking as necessary.

---

This article may help you: http://www.yoda.arachsys.com/csharp/threads/lockchoice.shtml

Generally I would avoid locking on 'this', as private lock variables, provide better control. I would recommend locking on 'this', if it's a custom collection class, something along the lines of SyncRoot, if that is what is required.

Hasanain

ReferenceURL : https://stackoverflow.com/questions/6140048/difference-between-manual-locking-and-synchronized-methods