生产者 - 消费者堆栈行为，而不是队列

我已经编写了一个解决方案，标准的生产者 - 消费者问题使用一个大小为5的缓冲区和pthreads与一个空的和完整的信号量和互斥锁。我认为一切都按预期工作，但只是注意到我得到堆栈行为（LIFO）而不是预期的队列（FIFO）行为。我已经搜索，但无法找到任何类似的问题，因为除了订单以外，我正按预期生产和消费。生产者 - 消费者堆栈行为，而不是队列

这是一项家庭作业，所以我没有真正寻找代码我只是想知道在哪里寻找错误或知道为什么行为可能会比预期的不同。

struct data 
{ 
pthread_mutex_t mutex; 
sem_t full;    
sem_t empty; 
}; 

int bufferCount;   

buffer_item buffer[BUFFER_SIZE]; 
pthread_t thread; 

int insert_item(buffer_item item) 
{ 
    if (bufferCount < BUFFER_SIZE) 
    { 
    buffer[bufferCount] = item; 
    ++bufferCount; 
    return 0; 
    } 
    else 
    return -1; //insert failed 
} 

int remove_item(buffer_item *item) 
{ 
    if (bufferCount > 0) 
    { 
    *item = buffer[bufferCount - 1]; 
    --bufferCount; 
    return 0; 
    } 
    else 
    return -1; //error failed to remove 

} 

void Initialize (void *param) 
{ 
    struct data *locks = param; 

    pthread_mutex_init(&(locks->mutex), NULL); 
    sem_init(&(locks->full), 0, 0); 
    sem_init(&(locks->empty), 0, BUFFER_SIZE); 
    bufferCount = 0; 

} 

void *producer (void *param) 
{ 
    struct data *locks = param; 
    do 
    { 
    sleep(rand()%5 + 1); //sleep for between 1 and 5 seconds 
    buffer_item num = rand(); 
    sem_wait(&(locks->empty)); 
    pthread_mutex_lock(&(locks->mutex)); 
    if (insert_item(num)) 
    { 
     printf("Insert in producer failed\n"); 
     exit(1); 
    } 
    else 
     printf("Producer produced %d\n", num); 
    pthread_mutex_unlock(&(locks->mutex)); 
    sem_post(&(locks->full)); 
    }while(1); 
} 


void *consumer (void *param) 
{ 
    struct data *locks = param; 
    do 
    { 
    sleep(rand()%5 + 1); //sleep for between 1 and 5 seconds 
    buffer_item num; 
    sem_wait(&(locks->full)); 
    pthread_mutex_lock(&(locks->mutex)); 
    if (remove_item(&num)) 
    { 
     printf("Remove in consumer failed\n"); 
     exit(1); 
    } 
    else 
     printf("Consumer consumed %d\n", num); 
    pthread_mutex_unlock(&(locks->mutex)); 
    sem_post(&(locks->empty)); 
    }while(1); 
} 


int main(int argc, char *argv[]) 
{ 
    if (argc != 4) 
    { 
    printf("Incorrect number of arguments should be 4\n"); 
    exit (1); 
    } 
    int sleepTime = atoi(argv[1]); 
    int producerThreads = atoi(argv[2]); 
    int consumerThreads = atoi(argv[3]); 
    struct data *locks = (struct data *) malloc(sizeof(struct data)); 
    Initialize(locks); 

    for (int i =0; i < producerThreads; ++i) 
    pthread_create(&thread, NULL, producer, locks); 

    for(int i = 0; i < consumerThreads; ++i) 
    pthread_create(&thread, NULL, consumer, locks); 

    sleep(sleepTime); 
    free (locks); 
    return 0; 
}

来源

2014-03-19 user2514231

错误是在第42行 –

有趣.....我确信我可以发布代码和数百人可以使它更好，并修复它，但我想从中吸取教训。因此，一般来说，在生产者消费者问题中，可能会影响消费者从缓冲区中移除的订单。 – user2514231

你对我们的期望是什么？如果您编写的是LIFO而不是FIFO，那么显然您的消费者会从容器错误的端点消耗掉。但这很明显，你一定要自己检查这个 –

你的“错误”就在这里：*item = buffer[bufferCount - 1];

当你删除一个项目，你突然出现在阵列中最远的，这也是最后插入（因此LIFO行为）。你需要弹出第一个（和memcpy/index-keeping来移动缓冲区的开始）。

你做什么：

begin   <-end 
------------------- 
| | | | | | | | |x| 
------------------- 
       | 
       -> *item

你想做什么：

begin->   end 
------------------- 
|x| | | | | | | | | 
------------------- 
| 
-> *item

PS：有性能损失memcpy的缓冲区来重新调整数据数组的开始，这是为什么经常使用circular buffers。

来源

2014-03-19 10:19:15 lucasg

谢谢....认为这是我所忽视的只是盯着代码，没有看到任何不同的东西导致问题。 – user2514231

生产者 - 消费者堆栈行为，而不是队列

回答

相关问题