这是在 C# 中创建线程安全类的好设计吗？

Question

通常，当我想要一个线程安全的类时，我会执行以下操作：

public class ThreadSafeClass
{
    private readonly object theLock = new object();

    private double propertyA;
    public double PropertyA
    {
        get
        {
            lock (theLock)
            {
                return propertyA;
            }
        }
        set
        {
            lock (theLock)
            {
                propertyA = value;
            }
        }
    }

    private double propertyB;
    public double PropertyB
    {
        get
        {
            lock (theLock)
            {
                return propertyB;
            }
        }
        set
        {
            lock (theLock)
            {
                propertyB = value;
            }
        }
    }

    public void SomeMethod()
    {
        lock (theLock)
        {
            PropertyA = 2.0 * PropertyB;
        }
    }
}

它有效，但它非常冗长。有时我什至会为每个方法和属性创建一个锁对象，从而产生更多的冗长和复杂性。

我知道也可以使用 Synchronization 属性锁定类，但我不确定它的扩展性如何——因为我经常期望有数十万甚至数百万个线程安全对象实例.这种方法将为类的每个实例创建一个同步上下文，并要求该类从 ContextBoundObject 派生，因此不能从其他任何东西派生——因为 C# 不允许多重继承——这是一个显示停止器在很多情况下。

编辑：正如一些响应者所强调的，没有“灵丹妙药”线程安全类设计。我只是想了解我使用的模式是否是好的解决方案之一。当然，任何特定情况下的最佳解决方案都取决于问题。以下几个答案包含应考虑的替代设计。

编辑：此外，线程安全的定义不止一种。例如，在我上面的实现中，以下代码不是线程安全的：

var myObject = new ThreadSafeClass();
myObject.PropertyA++; // NOT thread-safe

那么，上面的类定义代表了一个好的方法吗？如果不是，对于具有类似行为的设计，对于一组类似的用途来说是线程安全的，您会推荐什么？

Answer 1

对于多线程问题没有“一刀切”的解决方案。对创建不可变类进行一些研究并了解不同的同步原语。

这是 semi-immutable 或 the-programmers-immutable 类的示例。

public class ThreadSafeClass
{
    public double A { get; private set; }
    public double B { get; private set; }
    public double C { get; private set; }

    public ThreadSafeClass(double a, double b, double c)
    {
        A = a;
        B = b;
        C = c;
    }

    public ThreadSafeClass RecalculateA()
    {
        return new ThreadSafeClass(2.0 * B, B, C);
    }
}

此示例将您的同步代码移动到另一个类并序列化对实例的访问。实际上，您真的不希望在任何给定时间对一个对象进行多个线程操作。

public class ThreadSafeClass
{
    public double PropertyA { get; set; }
    public double PropertyB { get; set; }
    public double PropertyC { get; set; }

    private ThreadSafeClass()
    {

    }

    public void ModifyClass()
    {
        // do stuff
    }

    public class Synchronizer
    {
        private ThreadSafeClass instance = new ThreadSafeClass();
        private readonly object locker = new object();

        public void Execute(Action<ThreadSafeClass> action)
        {
            lock (locker)
            {
                action(instance);
            }
        }

        public T Execute<T>(Func<ThreadSafeClass, T> func)
        {
            lock (locker)
            {
                return func(instance);
            }
        }
    }
}

下面是一个简单的示例，说明您将如何使用它。它可能看起来有点笨拙，但它允许您一次在实例上执行许多操作。

var syn = new ThreadSafeClass.Synchronizer();

syn.Execute(inst => { 
    inst.PropertyA = 2.0;
    inst.PropertyB = 2.0;
    inst.PropertyC = 2.0;
});

var a = syn.Execute<double>(inst => {
    return inst.PropertyA + inst.PropertyB;
});

Answer 2

我知道这听起来像是一个聪明的答案，但是......开发线程安全类的最佳方法是真正了解多线程、它的含义、它的复杂性以及它的含义。没有灵丹妙药。

• 首先you need a good reason to use it。线程是一种工具，您不想用新发现的锤子敲击所有东西。
• 其次，了解多线程的问题...deadlocks、race conditions、starvation等等
• 第三，确保值得。我说的是收益/成本。
• 终于...准备好进行大量调试。 Debugging multithreaded code 比标准的旧顺序代码困难得多。了解一些有关如何做到这一点的技巧。

说真的...不要尝试多线程（我的意思是在生产场景中），直到您知道自己要进入什么...这可能是一个巨大的错误。

编辑：你当然应该知道操作系统和你选择的语言的同步原语（我猜在这种情况下是 Windows 下的 C#）。

很抱歉，我不只是提供代码来使类线程安全。那是因为它不存在。一个完全线程安全的类可能会比仅仅避免线程要慢，并且可能会成为您正在做的任何事情的瓶颈......有效地撤消您通过使用线程实现的任何事情。

Answer 3

请记住，术语“线程安全”不是特定的；通过使用Monitor 锁，您在这里所做的更准确地称为“同步”。

也就是说，同步代码的冗长几乎是不可避免的。您可以通过以下方式减少示例中的一些空白：

lock (theLock)
{
    propertyB = value;
}

进入这个：

lock (theLock) propertyB = value;

至于这是否是适合您的正确方法，我们确实需要更多信息。同步只是“线程安全”的一种方法；不可变对象、信号量等都是适合不同用例的不同机制。对于您提供的简单示例（看起来您正在尝试确保 get 或 set 操作的原子性），那么看起来您已经做了正确的事情，但如果您的代码旨在更多插图而不是示例，那么事情可能没有那么简单。

Answer 4

由于似乎没有其他人这样做，这里是对您的具体设计的一些分析。

• 想要读取任何单个属性？线程安全
• 想要更新到任何单个属性？线程安全
• 想要读取单个属性，然后根据其原始值对其进行更新？不是线程安全的

线程 2 可以在线程 1 的读取和更新之间更新值。

• 想要同时更新两个相关属性？不是线程安全的

您最终可能会得到属性 A 具有线程 1 的值，而属性 B 具有线程 2 的值。

1. 线程 1 更新 A
2. 线程 2 更新 A
3. 线程 1 更新 B

4. 线程 2 更新 B

   • 想要同时读取两个相关属性？不是线程安全的

同样，您可能会在第一次和第二次阅读之间被打断。

我可以继续，但你明白了。线程安全完全取决于您计划如何访问对象以及您需要做出什么承诺。

Answer 5

您可能会发现 Interlocked 课程很有帮助。它包含几个原子操作。

Answer 6

您可以做的一件事可以帮助您避免额外的代码，那就是使用 PostSharp 之类的东西自动将这些 lock 语句注入您的代码中，即使您有数百个这样的语句。您只需要一个附加到类的属性，以及将添加额外锁定变量的属性实现。

Answer 7

根据我上面的评论 - 如果您希望允许同时阅读但只允许一位作者，它会变得有点毛茸茸。请注意，如果您有 .NET 3.5，请使用 ReaderWriterLockSlim 而不是 ReaderWriterLock 来处理这种类型的模式。

public class ThreadSafeClass
{
    private readonly ReaderWriterLock theLock = new ReaderWriterLock();

    private double propertyA;
    public double PropertyA
    {
        get
        {
            theLock.AcquireReaderLock(Timeout.Infinite);
            try
            {
                return propertyA;
            }
            finally
            {
                theLock.ReleaseReaderLock();
            }
        }
        set
        {
            theLock.AcquireWriterLock(Timeout.Infinite);
            try
            {
                propertyA = value;
            }
            finally
            {
                theLock.ReleaseWriterLock();
            }
        }
    }

    private double propertyB;
    public double PropertyB
    {
        get
        {
            theLock.AcquireReaderLock(Timeout.Infinite);
            try
            {
                return propertyB;
            }
            finally
            {
                theLock.ReleaseReaderLock();
            }
        }
        set
        {
            theLock.AcquireWriterLock(Timeout.Infinite);
            try
            {
                propertyB = value;
            }
            finally
            {
                theLock.ReleaseWriterLock();
            }
        }
    }

    public void SomeMethod()
    {
        theLock.AcquireWriterLock(Timeout.Infinite);
        try
        {
            theLock.AcquireReaderLock(Timeout.Infinite);
            try
            {
                PropertyA = 2.0 * PropertyB;
            }
            finally
            {
                theLock.ReleaseReaderLock();
            }
        }
        finally
        {
            theLock.ReleaseWriterLock();
        }
    }
}