Question

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

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

对于给定的实例设置，lock(a)是否等同于lock(b)？

我的意思是，锁定会互相排斥吗？如果我在一个线程中lock(a)而在另一个线程中lock(b)，我是否可以获得对之前创建的B单个实例的互斥访问权限？

Answer 1

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

The lock() documentation表示lock语句通过获取给定引用类型对象的互斥锁来将语句块标记为临界区。

a和b都是同一个对象，所以是的，它们是等价的。实际上a和b都是对同一对象的引用。

引用类型之间的强制转换操作不会更改基础对象的运行时类型;它只会更改用作该对象引用的值的类型。 Source

快速测试程序显示它确实按照记录的方式运行：

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");
            }
        }
    }
}

获得了一把锁 ... 10秒钟通过
释放锁 b获得的锁定释放b锁

lock（）类型转换是否安全？

1 个答案: