C# 中的线程安全属性

Question

我正在尝试在 C# 中创建线程安全属性，我想确保我处于正确的路径上 - 这是我所做的 -

private readonly object AvgBuyPriceLocker = new object();
private double _AvgBuyPrice;
private double AvgBuyPrice 
{
    get
    {
        lock (AvgBuyPriceLocker)
        {
            return _AvgBuyPrice;
        }
    }
    set
    {
        lock (AvgBuyPriceLocker)
        {
            _AvgBuyPrice = value;
        }
    }
}

阅读这篇文章，这似乎不是正确的方法-

C# 线程安全与 get/set

然而，本文似乎另有建议,

<一href="http://www.codeproject.com/KB/cs/Synchronized.aspx" rel="noreferrer">http://www.codeproject.com/KB/cs/Synchronized.aspx

有人吗有更确定的答案吗？

编辑：

我想为此属性执行 Getter/Setter 的原因是 b/c 我实际上希望它在设置时触发一个事件 - 所以代码实际上会像这样 -

public class PLTracker
{

    public PLEvents Events;

    private readonly object AvgBuyPriceLocker = new object();
    private double _AvgBuyPrice;
    private double AvgBuyPrice 
    {
        get
        {
            lock (AvgBuyPriceLocker)
            {
                return _AvgBuyPrice;
            }
        }
        set
        {
            lock (AvgBuyPriceLocker)
            {
                Events.AvgBuyPriceUpdate(value);
                _AvgBuyPrice = value;
            }
        }
    }
}

public class PLEvents
{
    public delegate void PLUpdateHandler(double Update);
    public event PLUpdateHandler AvgBuyPriceUpdateListener;

    public void AvgBuyPriceUpdate(double AvgBuyPrice)
    {
        lock (this)
        {
            try
            {
                if (AvgBuyPriceUpdateListener!= null)
                {
                    AvgBuyPriceUpdateListener(AvgBuyPrice);
                }
                else
                {
                    throw new Exception("AvgBuyPriceUpdateListener is null");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

我对编写代码还很陌生线程安全，所以请随时告诉我我是否以完全错误的方式进行操作！

将要

Answer 1

正如您所写的那样，锁是毫无意义的。例如，读取变量的线程将：

1. 获取锁。
2. 读取值。
3. 释放锁。
4. 以某种方式使用读取值。

在步骤 3 之后，没有什么可以阻止另一个线程修改该值。由于 .NET 中的变量访问是原子的（请参见下面的警告），因此锁实际上并没有实现太多目的：只是增加了开销。与解锁示例对比：

1. 读取值。
2. 以某种方式使用读取值。

另一个线程可能会更改步骤 1 和步骤 2 之间的值，这与锁定示例没有什么不同。

如果要确保在进行某些处理时状态不会更改，则必须读取该值并在锁的上下文中使用该值进行处理：

1. 获取锁。
2. 读取值。
3. 以某种方式使用读取值。
4. 释放锁。

话虽如此，在某些情况下，访问变量时需要锁定。这些通常是由于底层处理器的原因造成的：例如，在 32 位机器上无法将 double 变量作为单个指令读取或写入，因此您必须锁定（或使用替代策略）以确保不读取损坏的值。

Answer 2

由于您有一个原始值，因此锁定将正常工作 - 另一个问题中的问题是属性值是一个更复杂的类（可变引用类型） - 锁定将保护访问和检索由你的班级。

另一方面，如果您的属性值是可变引用类型，则锁定将无法防止使用类实例的方法检索后更改类实例，而这正是另一张海报所希望的。

Answer 3

线程安全不是您应该添加到变量中的东西，而是您应该添加到“逻辑”中的东西。如果你为所有变量添加锁，你的代码仍然不一定是线程安全的，但它会非常慢。
要编写线程安全程序，请查看代码并确定多个线程可以在何处使用相同的数据/对象。在所有这些关键地方添加锁或其他安全措施。

例如，假设以下伪代码：

void updateAvgBuyPrice()
{
    float oldPrice = AvgBuyPrice;
    float newPrice = oldPrice + <Some other logic here>
    //Some more new price calculation here
    AvgBuyPrice = newPrice;
}

如果同时从多个线程调用此代码，则您的锁定逻辑没有用处。想象一下线程 A 获取 AvgBuyPrice 并进行一些计算。现在，在完成之前，线程 B 也正在获取 AvgBuyPrice 并开始计算。与此同时，线程 A 完成并将新值分配给 AvgBuyPrice。然而，不久之后，它就会被线程 B 覆盖（它仍然使用旧值），并且线程 A 的工作已经完全丢失。

那么如何解决这个问题呢？如果我们要使用锁（这将是最丑陋和最慢的解决方案，但如果您刚刚开始使用多线程，则是最简单的），我们需要将所有更改 AvgBuyPrice 的逻辑放入锁中：

void updateAvgBuyPrice()
{
    lock(AvgBuyPriceLocker)
    {
        float oldPrice = AvgBuyPrice;
        float newPrice = oldPrice + <Some other code here>
        //Some more new price calculation here
        AvgBuyPrice = newPrice;
    }
}

现在，如果线程 B 想要执行以下操作当线程 A 仍然忙碌时，它将等待线程 A 完成，然后使用新值执行其工作。但请记住，任何其他也修改 AvgBuyPrice 的代码也应该在 AvgBuyPriceLocker 工作时锁定它！

不过，如果经常使用的话，速度会很慢。锁是昂贵的，并且有很多其他机制可以避免锁，只需搜索无锁算法即可。

Answer 4

无论如何，双精度数的读写都是原子的（源) 双精度数的读取和写入不是原子性的，因此有必要使用锁来保护对双精度数的访问，但是对于许多类型来说，读取和写入是原子性的，因此以下内容只是安全：

private float AvgBuyPrice
{
    get;
    set;
}

我的观点是，线程安全比简单地保护每个属性更复杂。举一个简单的例子，假设我有两个属性 AvgBuyPrice 和 StringAvgBuyPrice：

private string StringAvgBuyPrice { get; set; }
private float AvgBuyPrice { get; set; }

假设我这样更新平均购买价格：

this.AvgBuyPrice = value;
this.StringAvgBuyPrice = value.ToString();

这显然不是线程安全的，并且单独保护属性上述方法根本没有帮助。在这种情况下，锁定应该在不同的级别而不是在每个属性级别执行。

Answer 5

虽然是一个老问题，但它出现在谷歌搜索的顶部，所以我添加了一个回复。在您的示例中，get 储物柜在return 后不会被释放。因此，我建议在这种情况下在 try-finally 块中使用 ReaderWriterLockSlim，这非常适合您尝试实现的结果。它允许多个线程进行读取或独占访问进行写入：

private readonly ReaderWriterLockSlim AvgBuyPriceLocker = new ReaderWriterLockSlim();
private double _AvgBuyPrice = 0;

public double AvgBuyPrice {
    get {
        AvgBuyPriceLocker.EnterReadLock();
        try { return _AvgBuyPrice; }
        finally { AvgBuyPriceLocker.ExitReadLock(); }
    }
    set {
        AvgBuyPriceLocker.EnterWriteLock();
        try { _AvgBuyPrice = value; }
        finally { AvgBuyPriceLocker.ExitWriteLock(); }
    }
}