相关疑难解决方法(0)

可能重复:
C#中的重入锁定

如果我写这样的代码:

class Program {
    static void Main(string[] args) {
        Foo();
        Console.ReadLine();
    }

    static void Foo() {
        lock(_lock) {
            Console.WriteLine("Foo");
            Bar();
        }
    }

    static void Bar() {
        lock(_lock) {
            Console.WriteLine("Bar");
        }
    }

    private static readonly object _lock = new object();
}

我得到输出:

Foo
Bar

我预计这会陷入僵局,因为Foo获得了一个锁,然后等待Bar获得锁.但这不会发生.

锁定机制是否只允许这个,因为代码是在同一个线程上执行的？

为什么这段代码不会造成死锁？

   private static readonly object a = new object();

...

   lock(a)
   {
      lock(a)
      {
         ....
      }
   }

我正在阅读Albahari关于线程的优秀电子书,并遇到以下情况他提到"一个线程可以以嵌套(可重入)方式重复锁定同一个对象"

lock (locker)
  lock (locker)
    lock (locker)
    {
       // Do something...
    }

以及

static readonly object _locker = new object();

static void Main()
{
  lock (_locker)
  {
     AnotherMethod();
     // We still have the lock - because locks are reentrant.
  }
}

static void AnotherMethod()
{
  lock (_locker) { Console.WriteLine ("Another method"); }
}

根据解释,任何线程都会阻塞第一个(最外面的)锁,并且只有在外部锁退出后才会解锁.

他说"当一个方法在一个锁中调用另一个方法时,嵌套锁定很有用"

为什么这有用？你什么时候需要这样做,它解决了什么问题？

可能重复:
C#中的重入锁定

我在这里看过StackOverflow和MSDN,并且无法相信我在互联网上找不到这个问题.

假设我有一个私有成员的课程,我想在几个公共方法中访问.这些公共方法将由​​不同的线程调用,因此需要同步.

public class MyClass
{
    private Object SomeSharedData = new Object();

    public void MethodA()
    {
        lock( SomeSharedData) {
            // do something
            MethodB();
        }
    }

    public void MethodB()
    {
        lock( SomeSharedData) {
            // do something
        }
    }
}

请注意,MethodA和MethodB可以由此类的用户调用,但MethodA也调用MethodB,这会导致嵌套锁定条件.

这保证是安全的吗？换句话说,.NET是通过引用计数锁来处理这个,所以当我弹出这些方法时,锁会减少吗？或者.NET在幕后执行一些魔术,它只是忽略了源自同一线程的对象上的所有后续锁定？

我正在学习C#中的多线程,我在下面看到了一个代码

static readonly object _locker = new object();

static void Main()
{
  lock (_locker)
  {
     AnotherMethod();
     // ...some work is going on
  }
}

static void AnotherMethod()
{
  lock (_locker) { Console.WriteLine ("Another method"); }
}

我想知道什么时候需要使用嵌套锁定？在这种情况下为什么不只使用一个锁？

在我下面的不安全类中,可以做些什么来阻止某人在没有获得锁定的情况下执行不安全的方法？

class Unsafe
{
    private static readonly object lockObj;

    void MethodA()
    {
        lock (lockObj)
        {
            // do some things
            DoUnsafeThing();
        }
    }

    void MethodB()
    {
        lock (lockObj)
        {
            // do some things
            DoUnsafeThing();
        }
    }

    void DoUnsafeThing()
    {
        if (callerHasLock)
            // Do the unsafe thing
        else
            return; // or throw some exception
    }
}

再次获取锁定DoUnsafeThing()是一个选项:

void DoUnsafeThing()
{
    lock (lockObj)
    {
        // Do the unsafe thing
    }
}

但DoUnsafeThing()现在可以被尚未拥有锁的线程调用.