Question

public class A { }
public class B:A { }

void foo()
{
   A a = new B();
   B b = a as B;
}

在特定情况下,<代码>24(a)等于lock(b)?

我指的是,锁定是相互排斥的吗? 如果I lock(a) in one read and lock(b) in another thread,我将能相互排斥地查阅早先建立的B的单一例子?

Answer 1

是lock(a){}相当于lock(b){}。

文件24(a)指出,24小时声明是一个关键部分,为某一参考类别获得相互排斥锁。

<代码>a和b>均为同一物体,因此相同。实际<代码>a和b均指同一物体。

不同参赛类型之间的投放作业并不改变下游物体的操作类型;它只改变用作该物体参考的价值类型。

快速测试方案表明,它确实有记录方式:

namespace ConsoleApplication2
{
    public class A { }
    public class B : A { }

    class Program
    {
        static A a = new B();

        static void MyThread()
        {
            B b = a as B;
            lock (b)
            {
                Console.WriteLine("b lock acquired");
                Console.WriteLine("releasing b lock");
            }

        }


        static void Main(string[] args)
        {
            System.Threading.Thread t = new System.Threading.Thread(MyThread);

            lock(a)
            {
                Console.WriteLine("a lock acquired");               
                t.Start();
                System.Threading.Thread.Sleep(10000);
                Console.WriteLine("Releasing a lock");
            }
        }
    }
}

a lock acquired
... 10 seconds pass
releasing a lock
b lock acquired
releasing b lock

友情链接