在异步或同步操作中使用监视器锁 [重复]

Question

我正在尝试提供一种锁定全局资源的解决方案，以强制锁定访问并且可用于同步或异步操作。

我创建了一个通用类State：

public class State<T>
{
  public class LockedState : IDisposable {
    public LockedState(State<T> state) { this.state = state; Monitor.Enter(this.state.theLock); } // would be great if this could be private
    public void Dispose() => Monitor.Exit(this.state.theLock);
    public ref T Val { get { return ref state.t; } }

    readonly State<T> state;
  };

  public State() { }
  public State(T t) { this.t = t; }
  public LockedState Locked { get { return new LockedState(this); } }
  readonly object theLock = new object();
  T t;
}

这里的想法是我可以在 Program 类中拥有一个全局“存储”：

public class Program {
    static public readonly State<ImmutableList<int>> TheList = new State<ImmutableList<int>>(ImmutableList<int>.Empty);
    static public readonly State<SomeType> SomeType = new State<SomeType>(SomeType());
}

然后唯一访问状态的方法是像这样获取锁：

using (var lTheList = Program.TheList.Locked) {
   lTheList.Val = lTheList.Val.Add(5));
}

在我的情况下，它比普通锁效果更好，因为它在获取/设置之前强制锁定（你不能忘记锁定）

（旁注这是一个好策略吗？）

问题是我不能在异步代码中使用上述内容：

using (var someType = Program.SomeType.Lock()) {
   var x = await someType.Val.SomeAsyncOp();
}

我得到一个例外：Object synchronization method was called from an unsynchronized block of code

我发现这篇帖子 How to protect resources that may be used in a multi-threaded or async environment? 有一个 AsyncLock 类但是我不明白如何将像 AsyncLock 这样的类放入我的 StateLock 类中......

State.Lock() 能否返回可用于同步和异步调用者的锁定状态？这真的是我要找的！

如果不是，我最好的前进方式是什么？使用SemaphoreSlim 并拥有State.Lock() 和State.AsyncLock() ？

谢谢！

Answer 1

您的代码令人担忧，因为任何恶意程序员都可以在 Program.TheList.Lock() 上使用 lock 而无需调用 .Dispose()，从而导致任何未来的调用者卡在构造函数中。构造函数应始终快速且干净地执行以避免损坏运行时。

你的代码有各种代码味道。

最好将 lambdas 传递到您的代码中并锁定它。

试试这个代码：

public class State<T>
{
    public State() { }
    public State(T t) { this.t = t; }

    private T t = default(T);
    private readonly object theLock = new object();

    public void With(Action<T> action)
    {
        lock (this.theLock)
        {
            action(this.t);
        }
    }

    public void Update(Func<T, T> action)
    {
        lock (this.theLock)
        {
            this.t = action(this.t);
        }
    }

    public R Select<R>(Func<T, R> action)
    {
        lock (this.theLock)
        {
            return action(this.t);
        }
    }
}

现在，连同您的 Program 课程，您可以这样做：

Program.TheList.Update(t => t.Add(5));

代码更少，更简单。

你也可以这样做：

async void Main()
{
    var wc = new State<WebClient>(new WebClient());

    string source = wc.Select<string>(x => x.DownloadString(new Uri("http://www.microsoft.com")));

    Console.WriteLine(source);
}

我希望这会有所帮助。

Answer 2

您不能在此处使用Monitor，因为Monitor（又名lock）本质上是基于线程的，并且要求您从获取的同一线程中“退出”锁锁 - 这正是您在async 代码中很少期望的情况。相反，请考虑SemaphoreSlim，您可以从中获取和释放令牌，但它不是线程绑定的。

伪代码：

// usually a field somewhere
SemaphoreSlim obj = new SemaphoreSlim(1);

// acquire lock:
obj.Wait(); // or await obj.WaitAsync() if want async acquire

// release lock:
obj.Release(); // often in a "finally"