C++ pthread没有给出预期的输出

我正在尝试使用信号量和pthread实现生产者-消费者问题操作系统。但我的产出与预期完全不同。这是我的密码：

    #include<iostream>
    #include<pthread.h>
    #include<fstream>
    #include<unistd.h>
    #include<queue>

    // define queue size
    #define QUEUE_SIZE 5

    // declare and initialize semaphore and read/write counter
    static int semaphore = 1;
    static int counter = 0;

    // Queue for saving characters
    static std::queue<char> charQueue;

    // indicator for end of file
    static bool endOfFile = false;

    // save arrays
    char consumerArray1[100];
    char consumerArray2[100];

    // function to wait for semaphore
    void wait()
    {
        while(semaphore<=0);
        semaphore--;
    }

    // function to signal the wait function
    void signal()
    {
        semaphore++;
    }

    void *Producer(void *ptr)
    {
        int i=0;
        std::ifstream input("string.txt");
        char temp;
        while(input>>temp)
        {
            wait();
            charQueue.push(temp);
            //std::cout<<"Producer:\nCounter: "<<counter<<" Semaphore: "<<semaphore<<std::endl;
            counter++;
            std::cout<<"Procuder Index: "<<i<<std::endl;
            i++;
            signal();
            sleep(2);
        }
        endOfFile = true;
        pthread_exit(NULL);
    }

    void *Consumer1(void *ptr)
    {
        std::cout<<"Entered consumer 1:"<<std::endl;
        int i = 0;
        while(counter<=0);
        while(!endOfFile)
        {
            while(counter<=0);
            wait();
            //std::cout<<"Consumer1:\nCounter: "<<counter<<" Semaphore: "<<semaphore<<std::endl;
            consumerArray1[i] = charQueue.front();
            charQueue.pop();
            i++;
            counter--;
            std::cout<<"Consumer1 index:"<<i<<" char: "<<consumerArray1[i]<<std::endl;
            signal();
            sleep(2);
        }
        consumerArray1[i] = '\0';
        pthread_exit(NULL);
    }

    void *Consumer2(void *ptr)
    {
        std::cout<<"Entered consumer 2:"<<std::endl;
        int i = 0;
        while(counter<=0);
        while(!endOfFile)
        {
            while(counter<=0);
            wait();
            //std::cout<<"Consumer2:\nCounter: "<<counter<<" Semaphore: "<<semaphore<<std::endl;
            consumerArray2[i] = charQueue.front();
            charQueue.pop();
            i++;
            counter--;
            std::cout<<"Consumer2 index: "<<i<<" char: "<<consumerArray2[i]<<std::endl;
            signal();
            sleep(4);
        }
        consumerArray2[i] = '\0';
        pthread_exit(NULL);
    }

    int main()
    {
        pthread_t thread[3];
        pthread_create(&thread[0],NULL,Producer,NULL);
        int rc = pthread_create(&thread[1],NULL,Consumer1,NULL);
        if(rc)
        {
            std::cout<<"Thread not created"<<std::endl;
        }
        pthread_create(&thread[2],NULL,Consumer2,NULL);
        pthread_join(thread[0],NULL);pthread_join(thread[1],NULL);pthread_join(thread[2],NULL);
        std::cout<<"First array: "<<consumerArray1<<std::endl;
        std::cout<<"Second array: "<<consumerArray2<<std::endl;
        pthread_exit(NULL);
    }

#包括
#包括
#包括
#包括
#包括
//定义队列大小
#定义队列大小5
//声明并初始化信号量和读/写计数器
静态int信号量=1；
静态整数计数器=0；
//保存字符的队列
静态std:：queue charQueue；
//文件结束指示符
静态布尔内函数=假；
//保存数组
char-consumerArray1[100]；
煤焦消耗品RAY2[100]；
//函数来等待信号量
无效等待（）
{
while（信号量>温度）
{
等待（）；
charQueue.push（临时）；
//std:：coutpthreads标准禁止在一个线程中访问对象，而另一个线程正在或可能正在修改它。您的
等待
和
信号
函数通过修改
信号量
（在
信号
中）违反了此规则调用
等待
的线程可能正在访问它。您也可以使用
计数器
执行此操作

如果你在
signal
和
wait
中所做的是合法的，你就不需要
signal
和
wait
。你可以直接访问队列，就像直接访问
信号灯一样。如果队列需要保护（我希望你知道它是这样的）然后，
信号灯
也需要保护，原因完全相同

允许编译器优化此代码：

while(semaphore<=0);

if (semaphore<=0) { while (1); }

while（信号量）你所做的事情需要一个适当的互锁修改机制，或者一些互斥机制。两者都可以工作。两者都不是竞争条件、挂起代码等的秘诀。你需要学习互斥锁、关键部分等。这些都与线程问题无关，但与线程问题相比，它们都是次要的所以没有任何输入验证。@WhozCraig我使用
wait
和
signal
函数添加了互斥。这有什么问题吗？否决投票的原因是什么？这个问题有什么问题？@ShantanuShinde对于一个刚接触线程的人来说，一开始就尝试编写自己的同步原语是很奇怪的艾夫斯。这是一件非常复杂的事情，在你非常非常熟悉它们的使用方法之前不应该尝试。@DavidSchwartz好吧，我被指派去做。我如何使用实际的信号量？要么按一下“pthread信号量”进入你最喜欢的搜索引擎或阅读或。我更改了代码以使用信号量标题，但现在我面临不同的问题。我应该在哪里发布新代码？你可以问一个新问题。确保没有任何对象（明确为此目的设计的同步对象除外）可以在一个线程中访问，而另一个线程正在或可能正在修改它。但下一票是什么？我已经根据stackoverflow的指导原则发布了这个问题。