Question

你好我有一个带有一些字段的对象。我希望这个对象是线程安全的。该对象将由两个线程访问并更改。但是，这些线程不会在同一字段上执行写操作

struct State
{
   public bool a;
   public bool b;
}
class LockedState{
 private State state;
 private readonly object @lock=new object();
 public bool A{
   get{ lock(@lock){ return this.state.a;}
   set{ lock(@lock){ this.state.a=value; }
}
public bool B{ ....}
}

我的问题是两个线程都更改对象的不同字段，但是都需要访问所有字段。我的第一个尝试是对所有对象使用单个lock，但我意识到这样做效率不高，因为我不希望在没有人在该字段上写入内容时，读取线程等待锁。 >

使用ReaderWriterLock会更好吗？

class State {

        private const int TIMEOUT = 100;
        private ReaderWriterLock alock= new ReaderWriterLock();
        private ReaderWriterLock block= new ReaderWriterLock();

        private bool a;
        private bool b;

        public bool A {
            get {
                this.alock.AcquireReaderLock(TIMEOUT);
                return a;
            }
            set {
                this.alock.AcquireWriterLock(TIMEOUT);
                this.a= value;

            }
        }
        public bool B{
            get {
                this.block.AcquireReaderLock(TIMEOUT);
                return b;
            }
            set {
                this.block.AcquireWriterLock(TIMEOUT);
                this.b = value;

            }
        }

        }

    }

如何在每个字段中使用读写器锁

0 个答案: