pthread调度问题

Question

我有两个采用生产者-消费者模式的线程。代码可以工作，但是消费者线程将陷入饥饿，然后生产者线程将陷入饥饿。

工作时，程序输出：

Send Data...semValue = 1
Recv Data...semValue = 0
Send Data...semValue = 1
Recv Data...semValue = 0
Send Data...semValue = 1
Recv Data...semValue = 0

然后发生一些变化，线程变得饥饿，程序输出：

Send Data...semValue = 1
Send Data...semValue = 2
Send Data...semValue = 3
...
Send Data...semValue = 256
Send Data...semValue = 257
Send Data...semValue = 258
Recv Data...semValue = 257
Recv Data...semValue = 256
Recv Data...semValue = 255
...
Recv Data...semValue = 0
Send Data...semValue = 1
Recv Data...semValue = 0
Send Data...semValue = 1
Recv Data...semValue = 0

我知道线程是由操作系统调度的，并且可以以不同的速率和随机顺序运行。我的问题：当我执行 YieldThread(调用 pthread_yield），Talker不应该给Listener一个运行的机会吗？为什么我会得到这种奇怪的安排？

下面的代码片段。 Thread类和Semaphore类是抽象类。我继续剥离了线程之间数据传递的队列，这样我就可以消除该变量。

const int LOOP_FOREVER = 1;

class Listener : public Thread
{
   public:
      Listener(Semaphore* dataReadySemaphorePtr)
         : Thread("Listener"),
           dataReadySemaphorePtr(dataReadySemaphorePtr)
      {
         //Intentionally left blank.
      }

   private:
      void ThreadTask(void)
      {
         while(LOOP_FOREVER)
         {
            this->dataReadySemaphorePtr->Wait();
            printf("Recv Data...");
            YieldThread();
         }
      }

      Semaphore*  dataReadySemaphorePtr;
};


class Talker : public Thread
{
   public:
      Talker(Semaphore* dataReadySemaphorePtr)
         : Thread("Talker"),
           dataReadySemaphorePtr(dataReadySemaphorePtr)
      {
         //Intentionally left blank
      }

   private:
      void ThreadTask(void)
      {
         while(LOOP_FOREVER)
         {
            printf("Send Data...");
            this->dataReadySemaphorePtr->Post();
            YieldThread();
         }
      }

      Semaphore*  dataReadySemaphorePtr;
};


int main()
{
   Semaphore  dataReadySemaphore(0);

   Listener   listener(&dataReadySemaphore);
   Talker     talker(&dataReadySemaphore);

   listener.StartThread();
   talker.StartThread();

   while (LOOP_FOREVER); //Wait here so threads can run
}

Answer 1

不会。除非您使用锁来阻止它，否则即使一个线程产生它的量程，也不需要另一个线程接收下一个量程。

在多线程环境中，您永远无法对如何安排处理器时间做出假设；如果您需要强制执行正确的行为，请使用锁。

Answer 2

不管你相信与否，它以这种方式运行是因为这样效率更高。处理器每次在线程之间切换时，都会执行一次上下文切换，这会浪费一定的时间。我的建议是放弃它，除非您有另一个要求，例如最大延迟或队列大小，在这种情况下，除了“准备好侦听的数据”之外，您还需要另一个信号量来“准备好更多数据”。