c# - 关于C#中lock语句的困惑

Question

这是来自MSDN:lock 关键字确保一个线程不会进入代码的关键部分，而另一个线程则在关键部分。

关键部分是否必须与关键部分相同？

或者它的意思是:lock 关键字确保一个线程不会进入代码的任何由对象保护的临界区，而另一个线程则进入由同一对象保护的任何临界区。 ？

    class Program
{
    static void Main(string[] args)
    {
        TestDifferentCriticalSections();

        Console.ReadLine();
    }

    private static void TestDifferentCriticalSections()
    {
        Test lo = new Test();

        Thread t1 = new Thread(() =>
        {
            lo.MethodA();
        });
        t1.Start();

        Thread t2 = new Thread(() =>
        {
            lo.MethodB();
        });
        t2.Start();
    }
}

public class Test
{
    private object obj = new object();

    public Test()
    { }

    public void MethodA()
    {
        lock (obj)
        {
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine("A");
            }
        }
    }

    public void MethodB()
    {
        lock (obj)
        {
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine("B");
            }
        }
    }
}

Answer 1

问题措辞困惑，到目前为止的答案也不是特别清楚。让我将问题改写成几个问题:

(1) Does the lock statement ensure that no more than one thread is in the body of the lock statement at any one time?

否。例如:

static readonly object lock1 = new object();
static readonly object lock2 = new object();
static int counter = 0;
static object M()
{
    int c = Interlocked.Increment(ref counter);
    return c % 2 == 0 ? lock1 : lock2;
}

...
lock(M()) { Critical(); }

两个线程有​​可能同时在 lock 语句的主体中，因为 lock 语句锁定了两个不同的对象。线程 Alpha 可以调用 M() 并获得 lock1，然后线程 Beta 可以调用 M() 并获得 lock2。

(2) Assuming that my lock statement always locks on the same object, does a lock statement ensure that no more than one "active" thread is in the body of the lock at any one time?

是的。如果你有:

static readonly object lock1 = new object();
...
lock(lock1) { Critical(); }

然后线程Alpha可以拿到锁，线程Beta会阻塞直到锁可用，然后才进入锁体。

(3) Assuming that I have two lock statements, and both lock statements lock on the same object every time, does a lock statement ensure that no more than one "active" thread is in the body of either lock at any one time?

是的。如果你有:

static readonly object lock1 = new object();
...
static void X() 
{
    lock(lock1) { CriticalX(); }
}
static void Y() 
{
    lock(lock1) { CriticalY(); }
}

那么如果线程Alpha在X中拿了锁，而线程Beta在Y中，那么线程Beta会阻塞直到锁可用后才进入锁体。

(4) Why are you putting "active" in "scare quotes"?

提醒注意一个等待线程可能在锁体中的事实。您可以使用 Monitor.Wait 方法“暂停”锁体中的线程，并允许被阻塞的线程变为事件状态并进入该锁体(或锁定同一个对象)。等待线程将保持其“等待”状态，直到收到脉冲。在它被脉冲后的某个时间，它重新加入“就绪”队列并阻塞直到锁中没有“事件”线程。然后它会从停止的地方继续。