c# - 这是在 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

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

这是一个半不可变 或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;
});