0

我有一个state变量，其感兴趣的字段是thread-safe并一直fresh使用一个ReaderWriterLockSlim。我已经细化了对所有字段的访问，因为我在其他地方单独使用它们。

虽然对于字段的单独访问它工作正常，但我还需要进行一些原子操作。在这种情况下，我需要额外的操作lock吗？

我有一个已经包含thread-safe字段的状态变量：

internal class State {

        private ReaderWriterLockSlim lck = new ReaderWriterLockSlim();

        private bool cmd_PopUp;

        private bool cmd_Shutdown;
        private bool cmd_Delay;



        public bool CMD_PopUp {
            get {
                try {
                    this.lck.EnterReadLock();
                    return this.cmd_PopUp;
                } finally {

                    this.lck.ExitReadLock();
                }

            }
            set {
                try {
                    this.lck.EnterWriteLock();
                    this.cmd_PopUp = value;
                } finally {

                    this.lck.ExitWriteLock();
                }
            }

        }

 //same goes for the other booleans
}

我已经有了这个线程安全的，并且我确保线程从内存中读取而不是从本地缓存中读取。但是我需要多个操作来完成原子操作。

原子操作

public async Task Run(State state)
{

     while(true)
        {
        //do i need a lock here
                        if (state.CMD_Delay) {
                            state.CMD_Delay = false;
                            state.CMD_PopUp = false;
        //end of potential lock ?
                        } else if (state.CMD_Shutdown) { //same here
                            state.CMD_PopUp = false;
                            state.CMD_Shutdown = false;
                            await SomeAction();
                        }
        }
}

正如您在我的文章中看到的那样，我while有一个if-else需要原子操作组的地方。我应该使用额外的lock还是有其他一些轻量级的解决方案？

4

1 回答 1

1

重用您现有的锁对我来说最有意义：

internal class State
{
  ...
  public void SetDelayState()
  {
    try {
      this.lck.EnterWriteLock();
      this.cmd_Delay = false;
      this.cmd_PopUp = false;
    } finally {
      this.lck.ExitWriteLock();
    }
  }
  public void SetShutdownState()
  {
    try {
      this.lck.EnterWriteLock();
      this.cmd_PopUp = false;
      this.cmd_Shutdown = false;
    } finally {
      this.lck.ExitWriteLock();
    }
  }
}

换句话说，将所有原子操作移动到您的State类型的成员。

旁注：您几乎可以肯定不需要读/写锁。仅当满足以下所有条件时才应使用读取器/写入器锁：

  • 一些代码路径是只读的，而另一些是读/写的。
  • 读者远多于作家。
  • 有大量连续读者。

如果其中任何一个不正确，那么lock是更好的选择。

于 2019-06-05T11:30:36.503 回答