C# 临界截面-仅单螺纹“；“睡觉”；上锁

我有一个关键部分（使用

lock

ed范围）

我希望只有最新的传入线程“休眠”在上面。因此，一旦关键部分被锁定，每个传入线程都会“终止”所有先前的休眠线程

有没有办法用C#实现这一点

---

谢谢

完成这项任务最有效的机制是使用任务，因此下面的解决方案实际上是异步的，而不是同步的，因为这样代码就简单多了。如果需要同步，可以同步等待任务

public class SingleWaiterLock
{
    private bool realLockTaken = false;
    private TaskCompletionSource<bool> waiterTCS = null;
    private object lockObject = new object();

    public Task<bool> WaitAsync()
    {
        lock (lockObject)
        {
            if (!realLockTaken)
            {
                realLockTaken = true;
                return Task.FromResult(true);
            }
            if (waiterTCS == null)
            {
                waiterTCS = new TaskCompletionSource<bool>();
                return waiterTCS.Task;
            }
            else
            {
                waiterTCS.SetResult(false);
                waiterTCS = new TaskCompletionSource<bool>();
                return waiterTCS.Task;
            }
        }
    }

    public void Release()
    {
        lock (lockObject)
        {
            if (waiterTCS != null)
            {
                waiterTCS.SetResult(true);
                waiterTCS = null;
            }
            else
            {
                realLockTaken = false;
            }
        }
    }
}

公共类SingleWaiterLock
{
private bool reallocktake=false；
private TaskCompletionSource waiterTCS=null；
私有对象lockObject=新对象（）；
公共任务WaitAsync（）
{
锁定（锁定对象）
{
如果（！reallocktake）
{
reallocktake=true；
返回Task.FromResult（true）；
}
if（waiterTCS==null）
{
waiterTCS=new TaskCompletionSource（）；
返回waiterTCS.Task；
}
其他的
{
waiterTCS.SetResult（false）；
waiterTCS=new TaskCompletionSource（）；
返回waiterTCS.Task；
}
}
}
公开无效释放（）
{
锁定（锁定对象）
{
if（waiterTCS！=null）
{
waiterTCS.SetResult（true）；
waiterTCS=null；
}
其他的
{
reallocktake=false；
}
}
}
}

---

wait方法返回的布尔值指示您是实际获取了锁（如果返回true）还是由稍后的人启动（返回false）。只有等待返回true时才应释放锁（但必须始终释放）。完成此操作最有效的机制似乎是使用任务，因此下面的解决方案实际上是异步的，而不是同步的，因为这样代码就简单多了。如果需要同步，可以同步等待任务

public class SingleWaiterLock
{
    private bool realLockTaken = false;
    private TaskCompletionSource<bool> waiterTCS = null;
    private object lockObject = new object();

    public Task<bool> WaitAsync()
    {
        lock (lockObject)
        {
            if (!realLockTaken)
            {
                realLockTaken = true;
                return Task.FromResult(true);
            }
            if (waiterTCS == null)
            {
                waiterTCS = new TaskCompletionSource<bool>();
                return waiterTCS.Task;
            }
            else
            {
                waiterTCS.SetResult(false);
                waiterTCS = new TaskCompletionSource<bool>();
                return waiterTCS.Task;
            }
        }
    }

    public void Release()
    {
        lock (lockObject)
        {
            if (waiterTCS != null)
            {
                waiterTCS.SetResult(true);
                waiterTCS = null;
            }
            else
            {
                realLockTaken = false;
            }
        }
    }
}

公共类SingleWaiterLock
{
private bool reallocktake=false；
private TaskCompletionSource waiterTCS=null；
私有对象lockObject=新对象（）；
公共任务WaitAsync（）
{
锁定（锁定对象）
{
如果（！reallocktake）
{
reallocktake=true；
返回Task.FromResult（true）；
}
if（waiterTCS==null）
{
waiterTCS=new TaskCompletionSource（）；
返回waiterTCS.Task；
}
其他的
{
waiterTCS.SetResult（false）；
waiterTCS=new TaskCompletionSource（）；
返回waiterTCS.Task；
}
}
}
公开无效释放（）
{
锁定（锁定对象）
{
if（waiterTCS！=null）
{
waiterTCS.SetResult（true）；
waiterTCS=null；
}
其他的
{
reallocktake=false；
}
}
}
}

---

wait方法返回的布尔值指示您是实际获取了锁（如果返回true）还是由稍后的人启动（返回false）。只有在等待返回true时才应释放锁（但必须始终释放）。

lock

在引擎盖下使用

Monitor

类，您可以尝试使用

Monitor

或

信号灯来获得所需的行为。您可以定义其他线程的情况吗？@MoB。其他线程被GC
lock
uses
Monitor
类终止和收集。在引擎盖下，您可以尝试使用
Monitor
或
Semaphore
获取所需的行为。您可以定义其他线程应该发生什么吗？@MoB。其他线程由GC终止和收集