Pthreads-如何解决此并发问题

Question

该程序包含一个称为循环缓冲区的单独文件，该文件的头和线程测试。该程序应该执行的操作是，创建一个具有所需大小的缓冲区，然后告诉他从该缓冲区中添加/删除数字。例如，。/ program 3 2 1将创建一个大小为3的缓冲区，并将向缓冲区中添加2个元素并删除1。问题是我无法控制并发性，就像我在运行程序时那样将添加1->删除1->添加1。我希望它添加/删除在切换到下一部分之前询问的次数。

我尝试了其他选项，例如添加互斥锁或变量，但是我做错了什么。我将在下面添加需要更改的代码部分：

//THIS IS THE HEADER OF BUFFER_CIRCULAR.h
#ifndef _BUFFER
#define _BUFFER
// Definición de la estructura búfer 
// El búfer no tiene tamaño fijo
struct Buffer_Circular {
    long *Buff; // Puntero al bloque de memoria dónde se almacenan los item
    int Nelementos; // Número máximo de elementos que se pueden almacenar
    int Extrae; // Indica la posición del próximo item a extraer
    int Inserta;    // Indica dónde se insertará el próximo item a almacenar
    int Pendientes_Consumir;    // Indica el número de items que aún no han sido extraídos
};

// Función de creación del búfer circular
// Parámetro de entrada:
//  Capacidad: número máximo de elementos que pueden ser almacenados
// Devuelve
//  Si no hay error retorna valor cero, en caso contrario devuelve un valor negativo
int Crea_Buffer(int Capacidad);

// Función que inserta un item en el búfer
// Parámetros de entrada:
//  Nuevo item a almacenar en el búfer
void *Inserta_Item(void *item);

// Función que extrae un item del búfer
// Parámetros de entrada:
//  Puntero que almacenará el item a extraer
void *Extrae_Item(void *item);

// Función que retorna el número de ítems pendientes de consumir
int Num_Pendientes_Consumir();

// Función que retorna la capacidad máxima del búfer
int Capacidad_Buffer();
#endif

// THIS IS CIRCULAR_BUFER DOC

#include <stdlib.h> // Requerido para malloc
#include <unistd.h>  // Requerido para Sleep  
#include <stdio.h>   // Requerido para lecturas y escrituras en los canales de entrada/salida


// Se incluye fichero cabecera en el que se declara los tipos y funciones de manejo del buffer circular
#include "Buffer_Circular.h"

// Puntero a una estructura de tipo Buffer_Circular
struct Buffer_Circular *Buffer=NULL;

// Función de creación del búfer circular
int Crea_Buffer(int Capacidad)
{
    long *p0;   
    struct Buffer_Circular *p1;
    int i;

    if (Capacidad <= 0) return -1;
    p0 = malloc( sizeof(long) * Capacidad);
    p1 = malloc(sizeof(struct Buffer_Circular));
    if ( (p0 != NULL) && (p1 != NULL) ) {
        Buffer = p1;
        Buffer->Buff = p0;
        Buffer->Inserta = 0;
        Buffer->Extrae = 0;
        Buffer->Nelementos = Capacidad;
        Buffer->Pendientes_Consumir = 0;
        for(i=0;i<Capacidad;i++) Buffer->Buff[i]=-1;
        return 0;
    }
    else {
        return -1;
    }
}


// Función que retorna el número de ítems pendientes de consumir
int Num_Pendientes_Consumir(){
return Buffer->Pendientes_Consumir;
}

// Función que retorna la capacidad máxima del búfer
int Capacidad_Buffer(){
return Buffer->Nelementos;
}

// Inserta un item en el búfer y actualiza los campos de datos del búfer
void *Inserta_Item(void *item)
{
    Buffer->Buff[Buffer->Inserta] = (long)item;
    if ( (long)item % 2 )
        sleep(1);
    printf("Se ha insertado en %d el item %ld\n",Buffer->Inserta,(long)item);
    Buffer->Inserta = (Buffer->Inserta+1) % Buffer->Nelementos;
    Buffer->Pendientes_Consumir++;
}

// Extrae un elemento del búfer y actualiza los campos de datos del búfer
void *Extrae_Item(void *item)
{
    item = (void *)(Buffer->Buff[Buffer->Extrae]);
    Buffer->Buff[Buffer->Extrae] = -1;
    printf("Se extrajo de %d el item %ld\n",Buffer->Extrae,(long)item);
    Buffer->Extrae = (Buffer->Extrae+1) % Buffer->Nelementos;
    Buffer->Pendientes_Consumir--;
}

// Prueba concurrente de acceso al búfer
// Se lanzan hilos productores y consumidores
// Al no haber sincronización entre los hilos,
// el resultado es que se puede corromper el búfer

//Archivos cabecera del sistema
#include <stdlib.h> // Requerido para atoi
#include <stdio.h> // Requerido para printf
#include <errno.h>
#include <pthread.h>
#include "Buffer_Circular.h"

// Función que comprueba y captura los parámetros pasados por línea de órdenes
void Comprobar_Argumentos(int argc, char *argv[], int *dim, int *np, int *nc);

// Hilo Productor: inserta un item en el búfer
void *Productor(void *item);

// Hilo Consumidor: extrae un item del búfer
void *Consumidor(void *item);

// Rutina que lanza los hilos productores y consumidores
void test_recurso_hilos(int np, int nc);


// Función que comprueba y captura los parámetros pasados por línea de órdenes
void Comprobar_Argumentos(int argc, char *argv[], int *dim, int *np, int *nc){
    if (argc != 4) {
        fprintf(stderr,"Invocación incorrecta: ./fich_ejec dim_buff num_prod num_cons\n");      
        exit(-1);
    }

    *dim = atoi(argv[1]);
    if (*dim<1) {
        fprintf(stderr,"Invocación incorrecta. La dimensión del búfer debe ser >0: ./fich_ejec dim_buff num_prod num_cons\n");
        exit(-1);
    }

    *np = atoi( argv[2] );
    if ( *np < 0 ) {
        fprintf(stderr,"Invocación incorrecta. El número de hilos productores debe ser >0: ./fich_ejec dim_buff num_prod num_cons\n");
        exit(-1);
    }

    *nc = atoi( argv[3] );
    if ( *nc < 0 ) {
        fprintf(stderr,"Invocación incorrecta. El número de hilos consumidores debe ser >0: ./fich_ejec dim_buff num_prod num_cons\n");
        exit(-1);
    }   
}

// this is the part from the tests that needs to be changed
//Num_Pendientes_Consumir() returns the number of how many are left to consume
//Capacidad_Buffer() returns the size of the buffer

// Producer thread: adds item to buffer. 
void *Productor(void *item){
    while (Num_Pendientes_Consumir() == Capacidad_Buffer()) ;

    Inserta_Item(item);
    pthread_exit(NULL);
}

// Extracting thread: extracts item from buffer
void *Consumidor(void *item)
{
    while (Num_Pendientes_Consumir() == 0) ;
    Extrae_Item(item);
    pthread_exit(NULL);
}

// Rutina que lanza los hilos productores y consumidores
void test_recurso_hilos(int np, int nc)
{
  pthread_t *productores;
  pthread_t *consumidores;
  int ret;
  long int i;
  void* dummy;

  productores=malloc(np*sizeof(pthread_t));
  if (productores==NULL) {
    fprintf(stderr,"Error en la petición de memoria para pthread_t productores\n");
    exit(-1);
  }

  consumidores=malloc(nc*sizeof(pthread_t));
  if (consumidores==NULL) {
    fprintf(stderr,"Error en la petición de memoria para pthread_t consumidores\n");
    exit(-1);
  }

  for(i=0; i<np; i++) {
    ret = pthread_create(&productores[i], NULL, Productor, (void *)i);
    if (ret) {
    errno=ret;
    fprintf(stderr,"error %d: %s\n",errno,strerror(errno));
        exit(-1);
    }
  }

  for (i=0; i<nc; i++) {
    ret=pthread_create(&consumidores[i], NULL, Consumidor, (void *)i);
    if (ret) {
    errno=ret;
    fprintf(stderr,"error %d: %s\n",errno,strerror(errno));
        exit(-1);
    }
  }

  for(i=0;i<np;i++) {
    ret=pthread_join(productores[i],&dummy);
    if (ret) {
    errno=ret;
    fprintf(stderr,"Error %d en el join del hilo productor %d: %s\n",errno,i,strerror(errno));
    exit(-1);
    }
  }

  for(i=0;i<nc;i++) {
    ret=pthread_join(consumidores[i],&dummy);
    if (ret) {
    errno=ret;
    fprintf(stderr,"Erro %d en el join del hilo consumidor %d: %s\n",errno,i,strerror(errno));
    exit(-1);
    }
  }
}

// Función main:
// Invocación:
//  # ./fich_ejec dim_buff num_prod num_cons
//  fich_ejec: nombre del archivo que contiene el código ejecutable
//  dim_buff: dimensión del búfer (>0)
//  num_prod: número de hilos productores (>=0)
//  num_cons: número de hilos consumidores (>=0)
//
int main(int argc, char *argv[]) {
  int dim,np,nc;

  printf("»»» Comienza la prueba del búfer...\n");
  Comprobar_Argumentos(argc, argv,&dim,&np,&nc);
  if (Crea_Buffer(dim) < 0) {
    fprintf(stderr,"Error al crear buffer\n");
    exit(-1);
  }
  test_recurso_hilos(np,nc);
  printf("»»» Fin de la prueba del búfer\n");
  exit(0);
}