Question

问题是我一直在使用lock statement来保护我的代码的关键部分，但现在，我意识到我可以允许并发执行该关键代码，但是满足了一些条件。
有没有办法调节锁？

Answer 1

我认为这个问题会喊“竞争条件！”。如果在检查后不久条件从true变为false，但在线程进入代码的关键部分之前怎么办？或者在线程正在执行它的过程中？

Answer 2

我不是线程专家，但听起来你可能正在寻找这样的东西（双重检查锁定）。我们的想法是在获得锁定之前和之后检查条件。

private static object lockHolder = new object();

if (ActionIsValid()) {
  lock(lockHolder) {
    if (ActionIsValid()) {
       DoSomething();    
    }
  }
}

Answer 3

bool locked = false;
if (condition) {
    Monitor.Enter(lockObject);
    locked = true;
}
try {
    // possibly critical section
}
finally {
    if (locked) Monitor.Exit(lockObject);
}

编辑：是的，除非你可以确保在线程进入时条件是恒定的，否则会出现竞争状态。

Answer 4

Action doThatThing = someMethod;

if (condition)
{
  lock(thatThing)
  {
     doThatThing();
  }
}
else
{
  doThatThing();
}

Answer 5

实际上，为了避免竞争条件，我很想在这里使用ReaderWriterLockSlim - 将并发访问视为读锁，将独占访问视为写锁。这样一来，如果条件发生变化，你将不会在该地区盲目执行某些不恰当的代码（假设它是安全的）;有点冗长，但是（格式化为空格）：

        if (someCondition) {
            lockObj.EnterReadLock();
            try { Foo(); }
            finally { lockObj.ExitReadLock(); }
        } else {
            lockObj.EnterWriteLock();
            try { Foo(); }
            finally { lockObj.ExitWriteLock(); }
        }

Answer 6

如上所述，使用Double-checked locking pattern。这就是IMO的诀窍:)。

确保将锁定对象作为 static ，如not.that.dave.foley.myopenid.com的示例中所列。

Answer 7

如果您有许多需要条件锁定的方法/属性，则不想一遍又一遍地重复相同的模式。我提出以下技巧：

非重复条件锁定模式

使用私有struct实现IDisposable的帮助，我们可以封装条件/锁，而没有可测量的开销。

public void DoStuff()
{
    using (ConditionalLock())
    {
        // Thread-safe code
    }
}

这很容易实现。这是演示此模式的示例类：

public class Counter
{
    private static readonly int MAX_COUNT = 100;

    private readonly bool synchronized;
    private int count;
    private readonly object lockObject = new object();

    private int lockCount;

    public Counter(bool synchronized)
    {
        this.synchronized = synchronized;
    }

    public int Count
    {
        get
        {
            using (ConditionalLock())
            {
                return count;
            }
        }
    }

    public int LockCount
    {
        get
        {
            using (ConditionalLock())
            {
                return lockCount;
            }
        }
    }

    public void Increase()
    {
        using (ConditionalLock())
        {
            if (count < MAX_COUNT)
            {
                Thread.Sleep(10);
                ++count;
            }
        }
    }

    private LockHelper ConditionalLock() => new LockHelper(this);

    // This is where the magic happens!
    private readonly struct LockHelper : IDisposable
    {
        private readonly Counter counter;
        private readonly bool lockTaken;

        public LockHelper(Counter counter)
        {
            this.counter = counter;

            lockTaken = false;
            if (counter.synchronized)
            {
                Monitor.Enter(counter.lockObject, ref lockTaken);
                counter.lockCount++;
            }
        }

        private void Exit()
        {
            if (lockTaken)
            {
                Monitor.Exit(counter.lockObject);
            }
        }

        void IDisposable.Dispose() => Exit();
    }
}

现在，让我们创建一个演示其正确性的小示例程序。

class Program
{
    static void Main(string[] args)
    {
        var onlyOnThisThread = new Counter(synchronized: false);
        IncreaseToMax(c1);

        var onManyThreads = new Counter(synchronized: true);
        var t1 = Task.Factory.StartNew(() => IncreaseToMax(c2));
        var t2 = Task.Factory.StartNew(() => IncreaseToMax(c2));
        var t3 = Task.Factory.StartNew(() => IncreaseToMax(c2));
        Task.WaitAll(t1, t2, t3);

        Console.WriteLine($"Counter(false) => Count = {c1.Count}, LockCount = {c1.LockCount}");
        Console.WriteLine($"Counter(true)  => Count = {c2.Count}, LockCount = {c2.LockCount}");
    }

    private static void IncreaseToMax(Counter counter)
    {
        for (int i = 0; i < 1000; i++)
        {
            counter.Increase();
        }
    }
}

输出：

Counter(false) => Count = 100, LockCount = 0
Counter(true)  => Count = 100, LockCount = 3002

现在，您可以让呼叫者决定是否需要锁定（代价高昂）。

Answer 8

我猜你有一些看起来像这样的代码：

private Monkey GetScaryMonkey(int numberOfHeads){
    Monkey ape = null;        
    lock(this) {
        ape = new Monkey();
        ape.AddHeads(numberOfHeads);            
    }
    return ape;
}

为了使这个有条件，你不能这样做：

private Monkey GetScaryMonkey(int numberOfHeads){
    if ( numberOfHeads > 1 ) {
         lock(this) {
            return CreateNewMonkey( numberOfHeads );          
        }
    }
    return CreateNewMonkey( numberOfHeads );
}

应该工作，不是吗？

如何在C＃中编写条件锁？

8 个答案:

非重复条件锁定模式

输出：