0

当需要多线程访问时，我一直在对值类型属性使用锁定。此外，我一直希望更加努力地应用适当的访问修饰符，尤其是在我的库代码中，这些代码开始在多个项目中变得有用。我已经编写了一些代码，并希望对其中的各种策略进行评论，以获取属性并锁定它们包装的成员变量。谢谢。

使用系统；

公开课程序
{
    静态无效主要（字符串 [] 参数）
    {
        SomeValueType svt = new SomeValueType();
        SomeReferenceType srt = new SomeReferenceType();        
        PermissionsAndLocking p = new PermissionsAndLocking(5, svt, srt);

        //无效的。
        //pX = 6;

        //无效的
        //p.Svt = new SomeValueType();
        //无效的
        //p.Svt.X = 1;
        //有效，但会更改p.Svt的副本，因为Svt是一个值类型。
        SomeValueType svt2 = p.Svt;
        svt2.X = 7;

        //无效的
        //p.Srt = new SomeReferenceType();
        //有效，改变p.Srt的成员数据。
        p.Srt.X = 8;        
        SomeReferenceType srt2 = p.Srt;
        srt2.X = 9;

        Console.WriteLine("按任意键。");
        Console.Read();
    }
}

公共类 PermissionsAndLocking
{
    //_x 不能在类外更改。
    //_x 不能“同时”改变它正在被访问？？？
    私有只读对象 _xLock = new object();
    私人int _x；
    公共诠释 X
    {
        得到
        {
            锁 (_xLock)
            {
                返回_x；
            }
        }
        私人集
        {
            锁 (_xLock)
            {
                _x = 值；
            }
        }
    }

    //_svt 及其成员不能分配给类外。
    //_svt 不能在被访问的“同时”改变。
    私有只读对象 _svtLock = new object();
    私人 SomeValueType _svt;
    公共 SomeValueType Svt
    {
        得到
        {
            锁 (_svtLock)
            {
                返回_svt；
            }
        }
        私人集
        {
            锁 (_svtLock)
            {
                _svt = 价值；
            }
        }
    }

    //private on set适用于=，但成员数据仍然可以被操作...
    //锁定未完成，因为引用被返回，可以稍后访问？？？
    私有只读对象 _srtLock = new object();
    私人 SomeReferenceType _srt;
    public SomeReferenceType Srt
    {
        得到
        {
            锁 (_srtLock)
            {
                返回_srt；
            }
        }
        私人集
        {
            锁 (_srtLock)
            {
                _srt = 值；
            }
        }
    }

    public PermissionsAndLocking(int x, SomeValueType svt, SomeReferenceType srt)
    {
        _x = x;
        _svt = svt;
        _srt = srt;
    }
}

公共结构 SomeValueType
{
    公共诠释 X；
}

公共类 SomeReferenceType
{
    公共诠释 X；
}
4

2 回答 2

2

您需要阅读有关多线程和并发的信息。锁定是关于在不变量无效时保护不变量，即，当不变量无效时，防止并发访问不变量所依赖的共享内存。第一步是了解您的代码例程具有哪些不变量，其次，在哪个代码块中不变量无效。

例如，属性 getter 没有内在的需要与锁同步。它只读取属性值。进行此读取时，哪些不变量无效？读取变量、递增变量，然后将递增的值写回属性的操作可能需要锁定，但锁定单独的 getter 和 setter 是完全不够的。整个操作，包括读取和写入，都必须在受保护的块内。

于 2009-09-29T01:32:41.643 回答
-5
  1. 您应该始终lock是静态对象，因此您应该标记_svtLock为静态以使锁定生效。
  2. _x不能在课堂外更改。真的。它必须通过 更改X。
  3. 如果您正确实施锁定（参见 1），则_x在访问时无法更改。
于 2009-09-29T01:32:40.340 回答