버퍼가 생산자로부터의 입력보다 작 으면 생산자/소비자가 교착 상태에있는 것 같습니다.

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; 
} 

버퍼가 단일 클라이언트의 메시지보다 클 때 주로 작동 (16, 예를 들어, 더 큰 buffer_size함으로써). 그러나 그것을 더 작게 만들면 교착 상태에 빠져있는 것처럼 보이며 많은 연구를 한 후에도 이유를 파악할 수 없습니다. 내가 디버거에서 코드를 실행하면 코드는

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

왜 코드가 여기에 실속하고 나는 그것이 실속에서 어떻게 방지 할 수 있습니다 라인에 실속 나타 납니까?

Answer 1

"메시지보다 작음"이라고 했습니까? 버퍼가 하나의 메시지 만 저장할 정도로 크지 않은 경우 생산자가 큐에 글쓰기를 중간에 멈추고 소비 할 항목이 있음을 소비자에게 알려주지 않습니다.

코드를 간략히 살펴보면 하나의 메시지 만 쓸 수 없다면 작성 루프에서 차단되고 함수의 마지막 부분에서 pthread_cond_signal 호출이 발생하지 않음을 확인할 수 있습니다. 소비자에게 알리고 버퍼를 비울 수 없습니다.

이 문제는 주된 문제입니다. 소비자가 소비하기 시작할 수있는 기본 단위는 대기열에 들어야합니다. 두 가지 방법으로 문제를 해결할 수 있습니다. 버퍼가 메시지에 대해 충분히 큰지 확인하거나 메시지를 더 작은 단위로 처리 가능하게 만들고 각 단위 후에 소비자에게 알립니다 (pthread_cond_signal).