Производитель / потребитель, кажется, находится в тупике, когда буфер меньше, чем ввод от производителя

Question

Я сделал кольцевой буфер с записью нескольких клиентов (в конце я хочу, чтобы они писали сообщения разного размера) в буфер. Сервер считывает их. Он основан на коде проблемы потребителя / производителя:

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>

#define BUFFER_SIZE 10

struct cBuf{
    char    *buf;  
    int     size; 
    int     start; 
    int     end;    
    pthread_mutex_t mutex;
    pthread_cond_t  buffer_full;
    pthread_cond_t  buffer_empty;
};

struct cBuf cb;

void buf_Init(struct cBuf *cb, int size) {
    int i;
    cb->size  = size + 1; 
    cb->start = 0;
    cb->end   = 0; 
    cb->buf = (char *)calloc(cb->size, sizeof(char));   
}
void buf_Free(struct cBuf *cb) {
    free(cb->buf);
}
int buf_IsFull(struct cBuf *cb) {
    return (cb->end + 1) % cb->size == cb->start; 
}
int buf_IsEmpty(struct cBuf *cb) {
    return cb->end == cb->start; 
}

int buf_Insert(struct cBuf *cb, char *elem) {

    int i,j;
    pthread_mutex_lock(&(cb->mutex));
    for (i=0; i < strlen(elem); ++ i){
        if (buf_IsFull(cb)==1) printf("\nProducer (buf_Insert) is waiting ");
        while(buf_IsFull(cb)){                      
            pthread_cond_wait(&(cb->buffer_empty),&(cb->mutex));
        } 

        cb->buf[cb->end] = elem[i]; 
        cb->end = (cb->end + 1) % cb->size;     
        printf("%c-",elem[i]);
    }

    pthread_cond_signal(&(cb->buffer_full));
    pthread_mutex_unlock(&(cb->mutex));     
    return 0;       
}

int buf_Read(struct cBuf *cb, char *out) {
    int i,j;
    pthread_mutex_lock(&(cb->mutex));
    if (buf_IsEmpty(cb))printf("\nConsumer (buf_Read) is waiting ");
    while(buf_IsEmpty(cb)){
        pthread_cond_wait(&(cb->buffer_full),&(cb->mutex));
    }

    for (i=0;i<BUFFER_SIZE-1;i++){
        if (cb->start == cb->end) break;

        out[i] = cb->buf[cb->start];
        cb->buf[cb->start] = '_';
        cb->start = (cb->start + 1) % cb->size;

        printf("%c-",out[i]);
    }
    pthread_cond_signal(&(cb->buffer_empty));
    pthread_mutex_unlock(&(cb->mutex)); 
    return 0;
}

void * client(void *cb){
    pthread_detach(pthread_self());

    struct cBuf *myData;
    myData = (struct cBuf*) cb;

    char input[]="Hello World!";

    if (buf_Insert(myData, input)) printf("\n");
    return 0;
}

int main(void) {
    char out[60];
    pthread_t thread;
    int i;

    pthread_cond_init(&(cb.buffer_full),NULL);
    pthread_cond_init(&(cb.buffer_empty),NULL);

    buf_Init(&cb, BUFFER_SIZE);

    for (i = 0; i<1; i++){
            if(pthread_create (&thread,NULL, client, (void *) &cb) !=0){
            #ifdef DEBUG
            printf("\nDEBUG (Main Thread) - Error while creating thread");
            #endif
        } else {
            #ifdef DEBUG
            printf("\nDEBUG (Main Thread) - Thread created");
            #endif
        }
    }

    while (1){
        if (buf_Read(&cb,out)) printf ("succes");
    }

    buf_Free(&cb);
    return 0;
}

В основном это работает, когда буфер больше, чем сообщение одного клиента (путем buffer_size больше, например, 16). Однако, когда я делаю его меньше, кажется, что он заходит в тупик, и даже после долгих исследований я не могу понять, почему. Когда я запускаю код в отладчике, код появляется на линии

pthread_cond_wait(&(cb->buffer_empty),&(cb->mutex));

Почему код останавливается здесь и как я могу предотвратить его остановку?

Answer 1

Вы сказали "меньше, чем сообщение", в единственном числе? Если буфер недостаточно велик, чтобы хранить хотя бы одно сообщение, то производитель перестанет на полпути записывать его в очередь и никогда не сможет уведомить потребителя о том, что ему есть что потреблять.

Краткое сканирование кода, кажется, подтверждает, что - если даже одно сообщение не может быть записано, вы блокируете цикл записи и не получаете доступ к pthread_cond_signal Вызов в конце функции, так что вы никогда не уведомите потребителя, и он не сможет освободить буфер.

Эта проблема принципиальная. Элементарная единица, которую потребитель может начать потреблять, должна помещаться в очередь. Вы можете решить проблему двумя способами: либо убедитесь, что буфер достаточно велик для сообщения, либо сделайте сообщение обрабатываемым в меньших единицах и уведомите потребителя (pthread_cond_signal) после каждого блока.