Pracuję nad programem, który zajmuje się dostępem do wielu wątków, wpłatami i wycofywaniem z ograniczonego kontenera buforowego. Zauważyłem kilka poważnych problemów z wątkami i podejrzewam, że mój bufor jest gdzieś częściowo lub zasadniczo niepoprawny.

Aby mieć pewność, że wiem, co z tym robię, byłbym wdzięczny za przejrzenie mojego kodu bufora. Klasa używa semafora, który zaimplementowałem gdzie indziej, który na razie zakładam (jeśli nie, szybko to zrozumiem!) Dodałem komentarze, które próbują wyjaśnić moje rozumowanie.

Po pierwsze, plik .h:

#ifndef BOUNDED_BUFFER_H
#define BOUNDED_BUFFER_H

#include "Semaphore.H"
#include <string> 
#include <vector>  

using namespace std; 

class Item{ //supposed to eventually be more extensible...seems silly with just a string for now

  public:
    Item(string _content){content = _content;} 
    string GetContent() {return content;}     

  private:  
};   

    class BoundedBuffer{

      public:
        BoundedBuffer(); 

        void Deposit(Item* _item); 
        Item* Retrieve();        
        int GetNumItems() {return count;} 
        vector<Item*> GetBuffer() {return buffer;} 
        void SetSize(int _size){
          capacity = _size;
          buffer.reserve(_size);  //or do I need to call "resize" 
        }  

      private:
        int capacity; 
        vector<Item*> buffer; //I originally wanted to use an array but had trouble with  
                              //initilization/sizing, etc. 
        int nextin; 
            int nextout; 
            int count; 

            Semaphore notfull;   //wait on this one before depositing an item
            Semaphore notempty;  //wait on this one before retrieving an item
        };

    #endif

Następnie .cpp:

#include "BoundedBuffer.H"
#include <iostream>

using namespace std; 

BoundedBuffer::BoundedBuffer(){

  notfull.SetValue(0); 
  notempty.SetValue(0); 
  nextin = 0; 
  nextout = 0; 
  count = 0; 
}

void BoundedBuffer::Deposit(Item* _item){
  if(count == capacity){ 
    notfull.P(); //Cannot deposit into full buffer; wait
  }

  buffer[nextin] = _item; 
  nextin = (nextin + 1) % capacity;  //wrap-around
  count += 1;
  notempty.V();  //Signal that retrieval is safe 
}

Item* BoundedBuffer::Retrieve(){
  if(count == 0){
    notempty.P(); //cannot take from empty buffer; wait 
  }

  Item* x = buffer[nextout]; 
  nextout = (nextout + 1) % capacity;
  buffer.pop_back();  //or a different erase methodology? 
  count -= 1; 
  notfull.V(); //Signal that deposit is safe 
  return x; 
}

Myślę, że problemy mogą wynikać z mojego wyboru wektora jako podstawowego kontenera (lub raczej z niewłaściwego użycia), lub może z potrzeby większej liczby mechanizmów blokujących dla bezpieczeństwa (zamki mutex, itp.). rzeczy, czy ktoś może przekazać jakieś opinie?