.NET 并发问题：我可以向另一个线程产生信号量吗

Question

我有多个线程共享信号量的使用。线程 A 持有信号量（使用锁），线程 B 和 C 正在等待同一信号量（也使用锁）。线程共享全局变量等。C

# 中是否有一种可以用来关闭线程 B 的技术？我可以在 A 中设置一个标志，并让线程 B 检查该标志，并在获得信号量的控制权后立即退出，但我不知道有什么技术可以允许线程 A 将信号量交给线程 B（并获取它）当线程 B 退出时返回），而不存在线程 C 夺取控制权的风险。

有人对如何解决这个设计问题有什么建议吗？如果我的方法不正确，我可以根据需要重写程序。

[编辑] 评论者指出我使用了错误的术语。评论者是正确的 - 我正在使用关键部分，但考虑到所有内容都在单个进程中运行，在此示例中，关键部分在功能上等同于更通用的术语“信号量”。

[编辑] 有人要求了解更多详细信息，所以这里是。

可以有多个线程执行代码 A。只有一个线程执行代码 B。

代码 A：

private static Thread workerThread = null;

lock (lockObject)
{
    ... do some work ...

    if (...condition...)
    {
        if (workerThread != null)
        {
            // Kill the worker thread and continue only after it is dead.
            quitWorkerThread = true;
            // Wait for the thread to die.
            while (workerThread.IsAlive)
            {
                Thread.Sleep(50);
            }
            workerThread = null;
            quitWorkerThread = false;
        } // if (workerThread != null)
    } // if (...condition...)

    ... do some more work ...

    if (...condition...)
    {
        if (workerThread == null)
        {
            // Start the worker thread.
            workerThread = new Thread(WorkerThread);
            workerThread.Start();
        } // if (workerThread == null)
    } // if (...condition...)

    ... do even more work ...

} // lock (lockObject)

代码 B：

private void WorkerThread()
{
    while (true)
    {
        if (quitWorkerThread)
        {
            return;
        }

        Thread.Sleep (2000);

        if (quitWorkerThread)
        {
            return;
        }

        lock(lockObject)
        {
            if (quitWorkerThread)
            {
                return;
            }
            ... do some work ...
        } // lock(lockObject)
    } // while (true)
} // WorkerThread

我怀疑我将使用 Aaron 解决方案的一种变体。我主要希望有更优雅的解决方案可用，但我怀疑就像这个项目的其他所有内容一样，这都是蛮力和极端情况:-(。

Answer 1

我相当确定没有办法将控制权交给特定线程，这似乎正是您想要做的。您只能让步 - 这由 Windows 调度程序决定接下来运行哪个线程。

情况是你有三个线程，A、B 和 C。A 拥有锁，B 和 C 正在等待它，并且你需要一种方法来保证 B 接下来执行。

显而易见的解决方案是使用多个锁和/或同步原语。您可以将lock 的语义与ManualResetEvent 结合起来。让线程 C 等待事件和临界区，但线程 B 只需等待临界区。在正常情况下，您在释放锁之前发出事件信号，这将由操作系统决定执行哪个线程。在特殊情况下，您根本不发出事件信号，让线程 B 继续执行，而 C 仍处于阻塞状态。

一旦 B 完成，您就向事件发出信号让 C 完成。

---

一个（未经测试的）示例是：

// Main thread is Thread A
object myLock = new Object();
AutoResetEvent myEvent = new AutoResetEvent(false);
ManualResetEvent completedEvent = new ManualResetEvent(false);

ThreadPool.QueueUserWorkItem(s =>
{
    for (int i = 0; i < 10000; i++)
    {
        lock (myLock)
        {
            // Do some work
        }
    }
    completedEvent.Set();
});  // Thread B

ThreadPool.QueueUserWorkItem(s =>
{
    for (int i = 0; i < 10000; i++)
    {
        myEvent.WaitOne();
        lock (myLock)
        {
            // Do some work
        }
    }
});  // Thread C

// Main loop for thread A
while (true)
{
    lock (myLock)
    {
        // Do some work
        if (SomeSpecialCondition)
            break;
        else
            myEvent.Set();
    }
}

completedEvent.WaitOne(); // Wait for B to finish processing
if (SomeSpecialCondition) // If we terminated without signaling C...
    myEvent.Set();        // Now allow thread C to clean up

这实际上是让线程 A 负责线程 C 何时执行。线程 A 和 B 将正常竞争，但由线程 A 向线程 C 发出事件信号。

Answer 2

看一下如何使用 Monitor 和 Monitor.Pulse 这不会让你完全得到你想要的特定线程的结果，但它允许你在线程和关键部分之间转移控制。

我不清楚你想解决什么问题。您还可以使用 ReaderWriterLockSlim 也是如此。

最后，在我看来，您的场景是使用 .NET 事件 相反。

Answer 3

（免责声明：如果您唯一的用例是该特定用例，@Aaronaught 简单使用 ManualResetEvents 的解决方案可能是最简单的。）

编辑了额外的免责声明： 如果您想扩展这一概念，请非常非常警惕死锁。

在某些情况下，无论 B 是否完成工作，您可能都希望 C 继续工作，但如果 C 正在等待，则始终希望 B 先行，这里有一个简单的解决方案：

    object lockObject = new object();
    int WaitCounter = 0;

    void B()
    {
        System.Threading.Interlocked.Increment(ref WaitCounter);

        try
        {
            lock (lockObject)
            {
            }
        }
        finally
        {
            System.Threading.Interlocked.Decrement(ref WaitCounter);
        }
    }

    void C()
    {
        while (true)
        {
            // always attempt to yield to other threads first
            System.Threading.Thread.Sleep(0);
            lock (lockObject)
            {
                if (WaitCounter > 0)
                    continue;

                // ...

                return;
            }
        }
    }

如果 额外的代码，但没有人声称并发是容易的。 :)

Answer 4

Aaronaught 的解决方案看起来不错，但我认为更简单的解决方案是使用更多的共享状态和一个锁。

基本上，您在线程之间传递控制权，然后线程决定它们是否该工作。如果不是，他们会简单地使用 PulseAll（将所有现有的等待线程移动到就绪队列中）并等待（发出脉冲，然后）再次获得锁。在某些时候，ThreadC 何时适合运行就已经决定了。

public class ThreadsGettinCrazy {
  static readonly _sync = new object();
  static bool _threadCReady = false;

  public void ThreadA() {
    while (true) {
      lock(_sync) {
        while(/* my condition not met */) {
          Monitor.PulseAll(_sync);
          Monitor.Wait(_sync);
        }
        // do work, possibly set _threadCReady = true
        Monitor.PulseAll(_sync);
      }
      if (/* i'm done */) break;
    }
  }

  public void ThreadB() {
    while (true) {
      lock(_sync) {
        while(/* my condition not met */) {
          Monitor.PulseAll(_sync);
          Monitor.Wait(_sync);
        }
        // do work, possibly set _threadCReady = true
        Monitor.PulseAll(_sync);
      }
      if (/* i'm done */) break;
    }
  }

  public void ThreadC() {
    lock(_sync) {
      while (!_threadCReady) {
        Monitor.PulseAll(_sync);
        Monitor.Wait(_sync);
      }
      // do work
    }
  }
}