Question

[编辑：看起来原始问题涉及一个double而不是整数。因此，如果我们将整数更改为double，我认为这个问题就存在。]

我很难从多个线程中使用的类中读取整数属性，有时会返回零值。初始化后，值不会更改。

这question解决了这个问题。共识是，即使我正在访问整数，我需要同步属性。（一些原始答案已被删除）。我没有在那里选择答案，因为我还没有解决我的问题。

所以我对此做了一些研究，我不确定使用哪种.Net 4的锁定机制，或者锁是否应该在类本身之外。

这是我想到的：

  public class ConfigInfo
  {
    private readonly object TimerIntervalLocker = new object();
    private int _TimerInterval;
    public int TimerInterval
    {
      get
      {
        lock (TimerIntervalLocker) {
          return _TimerInterval;
        }
      }
    }

    private int _Factor1;
    public int Factor1
    {
      set
      {
        lock (TimerIntervalLocker) {
          _Factor1 = value;
          _TimerInterval = _Factor1 * _Factor2;
        }
      }
      get
      {
        lock (TimerIntervalLocker) {
          return _Factor1;
        }
      }
    }

    private int _Factor2;
    public int Factor2
    {
      set
      {
        lock (TimerIntervalLocker) {
          _Factor2 = value;
          _TimerInterval = _Factor1 * _Factor2;
        }
      }
      get
      {
        lock (TimerIntervalLocker) {
          return _Factor2;
        }
      }
    }
  }

但是我读到这非常慢。

另一种方法是在用户端锁定ConfigData的实例，但这似乎是很多工作。我见过的另一种选择是Monitor.Enter和Monitor.Exit，但我认为Lock的语法较少是一样的。

那么创建类的属性线程的最佳实践是什么安全

Answer 1

一个。使用锁可能会很慢，因为它使用操作系统资源，如果属性的复杂性很低，那么自旋锁（或interlocked.compareexchange）会更快。

湾您必须确保线程不会进入锁定，并且通过从一个属性到另一个属性的调用被锁定。 - 如果发生这种情况（当前代码中不存在问题），则需要使锁定线程或任务敏感。

编辑：

如果该对象应该在初始化期间设置并且从不更改，则使其不可变（如.NET字符串）。删除所有公共setter并提供一个构造函数，其中包含用于定义初始状态的参数，以及用于创建具有已修改状态的新实例的其他方法/运算符（例如var newString =“Old string”+“was modified。”;）。 / p>

Answer 2

如果值永远不会改变，那么只需复制该实例并将每个线程传递给它自己的实例就更容易了。根本不需要锁定。

Answer 3

我认为你应该重写你的ConfigInfo课程，看起来像这样;那么你就不会遇到溢出或线程问题：

public sealed class ConfigInfo
{
    public ConfigInfo(int factor1, int factor2)
    {
        if (factor1 <= 0)
            throw new ArgumentOutOfRangeException("factor1");

        if (factor2 <= 0)
            throw new ArgumentOutOfRangeException("factor2");

        _factor1 = factor1;
        _factor2 = factor2;

        checked
        {
            _timerInterval = _factor1*_factor2;
        }
    }

    public int TimerInterval
    {
        get
        {
            return _timerInterval;
        }
    }

    public int Factor1
    {
        get
        {
            return _factor1;
        }
    }

    public int Factor2
    {
        get
        {
            return _factor2;
        }
    }

    private readonly int _factor1;
    private readonly int _factor2;
    private readonly int _timerInterval;
}

请注意，我正在使用checked来检测溢出问题。

否则某些值会产生错误的结果。

例如，57344 * 524288将在未经检查的整数运算中给出零（并且还有很多其他值将给出零，甚至更多会给出否定结果或正值“似乎”正确）。

Answer 4

最好，如评论中所述，使属性只读。我想到了以下可能性：

public class ConfigInfo
{
    private class IntervalHolder
    {
        public static readonly IntervalHolder Empty = new IntervalHolder();

        private readonly int _factor1;
        private readonly int _factor2;
        private readonly int _interval;

        private IntervalHolder()
        {
        }

        private IntervalHolder(int factor1, int factor2)
        {
            _factor1 = factor1;
            _factor2 = factor2;
            _interval = _factor1*_factor2;
        }

        public IntervalHolder WithFactor1(int factor1)
        {
            return new IntervalHolder(factor1, _factor2);
        }

        public IntervalHolder WithFactor2(int factor2)
        {
            return new IntervalHolder(_factor1, factor2);
        }

        public int Factor1
        {
            get { return _factor1; }
        }

        public int Factor2
        {
            get { return _factor2; }
        }

        public int Interval
        {
            get { return _interval; }
        }

        public override bool Equals(object obj)
        {
            var otherHolder = obj as IntervalHolder;
            return 
                otherHolder != null &&
                otherHolder._factor1 == _factor1 &&
                otherHolder._factor2 == _factor2;
        }
    }

    private IntervalHolder _intervalHolder = IntervalHolder.Empty;

    public int TimerInterval
    {
        get { return _intervalHolder.Interval; }
    }

    private void UpdateHolder(Func<IntervalHolder, IntervalHolder> update)
    {
        IntervalHolder oldValue, newValue;
        do
        {
            oldValue = _intervalHolder;
            newValue = update(oldValue);

        } while (!oldValue.Equals(Interlocked.CompareExchange(ref _intervalHolder, newValue, oldValue)));
    }

    public int Factor1
    {
        set { UpdateHolder(holder => holder.WithFactor1(value)); }
        get { return _intervalHolder.Factor1; }
    }

    public int Factor2
    {
        set { UpdateHolder(holder => holder.WithFactor2(value)); }
        get { return _intervalHolder.Factor2; }
    }
}

这样，您的 TimerInterval 值始终与其因子同步。唯一的问题是当某个线程读取其中一个属性而另一个线程从 ConfigInfo 之外写入它们时。第一个可能会得到错误的值，我没有看到任何方法来解决这个问题，而不引入单个锁定根。问题是读操作是否至关重要。

使类的属性线程安全的最佳实践是什么？

4 个答案: