Producteur Consommateur programme à l'aide des sémaphores et des pthreads

J'ai écrit un code pour le producteur-consommateur problème.Mais je ne suis pas aller la sortie.Il n'y a pas d'erreur de compilation,mais attention dans mon programme.Je suis confus.À essayer très dur.Mais ne pouvez pas l'obtenir.S'il vous plaît dites-moi quel est le problème dans mon programme.Quel sera le programme approprié.Je suis frustré.S'il vous plaît aider les gars.
Voici le code-

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include </usr/include/semaphore.h>
#define BUFF_SIZE   5           /* total number of slots */
#define NP          3           /* total number of producers */
#define NC          3           /* total number of consumers */
#define NITERS      4           /* number of items produced/consumed */
typedef struct {
int buf[BUFF_SIZE];   /* shared var */
int in;               /* buf[in%BUFF_SIZE] is the first empty slot */
int out;              /* buf[out%BUFF_SIZE] is the first full slot */
sem_t full;           /* keep track of the number of full spots */
sem_t empty;          /* keep track of the number of empty spots */
sem_t mutex;          /* enforce mutual exclusion to shared data */
} sbuf_t;
sbuf_t shared;
void *Producer(void *arg) {
int i, item, index;
index = (int) arg;
for (i = 0; i < NITERS; i++) {
/* Produce item */
item = i;
/* Prepare to write item to buf */
/* If there are no empty slots, wait */
sem_wait(&shared.empty);
/* If another thread uses the buffer, wait */
sem_wait(&shared.mutex);
shared.buf[shared.in] = item;
shared.in = (shared.in+1)%BUFF_SIZE;
printf("[P%d] Producing %d ...\n", index, item); fflush(stdout);
/* Release the buffer */
sem_post(&shared.mutex);
/* Increment the number of full slots */
sem_post(&shared.full);
/* Interleave  producer and consumer execution */
if (i % 2 == 1) sleep(1);
}
return NULL;
}
void *Consumer(void *arg) {
int i, item, index;
index = (int) arg;
for (i = NITERS; i > 0; i--) {
sem_wait(&shared.full);
sem_wait(&shared.mutex);
item = i;
item = shared.buf[shared.out];
shared.out = (shared.out + 1) % BUFF_SIZE;
printf("[C%d] Consuming  %d ...\n", index, item); fflush(stdout);
/* Release the buffer */
sem_post(&shared.mutex);
/* Increment the number of full slots */
sem_post(&shared.empty);
/* Interleave  producer and consumer execution */
if (i % 2 == 1) sleep(1);
}
return NULL;
}
int main() {
pthread_t idP, idC;
int index;
sem_init(&shared.full, 0, 0);
sem_init(&shared.empty, 0, BUFF_SIZE);
pthread_mutex_init(&shared.mutex, NULL);
for (index = 0; index < NP; index++) {
/* Create a new producer */
pthread_create(&idP, NULL, Producer, (void*)index);
}
/*create a new Consumer*/
for (index = 0;index < NC;index++) {
pthread_create(&idC, NULL, Consumer, (void*)index);
}
pthread_exit(NULL);
}

InformationsquelleAutor Twity 56876 | 2013-11-07

c pthreads semaphore

Peut-être vous devriez prendre les avertissements du Compilateur plus graves.
Incorrect types et de fonctions non définies sont généralement présentés
comme un avertissement...

Je n'ai pas vérifié la Logique de votre programme, mais le principe devrait fonctionner:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include </usr/include/semaphore.h>
//for sleep
#include <unistd.h>
#define BUFF_SIZE   5           /* total number of slots */
#define NP          3           /* total number of producers */
#define NC          3           /* total number of consumers */
#define NITERS      4           /* number of items produced/consumed */
typedef struct
{
int buf[BUFF_SIZE];   /* shared var */
int in;               /* buf[in%BUFF_SIZE] is the first empty slot */
int out;              /* buf[out%BUFF_SIZE] is the first full slot */
sem_t full;           /* keep track of the number of full spots */
sem_t empty;          /* keep track of the number of empty spots */
//use correct type here
pthread_mutex_t mutex;          /* enforce mutual exclusion to shared data */
} sbuf_t;
sbuf_t shared;
void *Producer(void *arg)
{
int i, item, index;
index = (int)arg;
for (i=0; i < NITERS; i++)
{
/* Produce item */
item = i;
/* Prepare to write item to buf */
/* If there are no empty slots, wait */
sem_wait(&shared.empty);
/* If another thread uses the buffer, wait */
pthread_mutex_lock(&shared.mutex);
shared.buf[shared.in] = item;
shared.in = (shared.in+1)%BUFF_SIZE;
printf("[P%d] Producing %d ...\n", index, item);
fflush(stdout);
/* Release the buffer */
pthread_mutex_unlock(&shared.mutex);
/* Increment the number of full slots */
sem_post(&shared.full);
/* Interleave  producer and consumer execution */
if (i % 2 == 1) sleep(1);
}
return NULL;
}
void *Consumer(void *arg)
{
int i, item, index;
index = (int)arg;
for (i=NITERS; i > 0; i--) {
sem_wait(&shared.full);
pthread_mutex_lock(&shared.mutex);
item=i;
item=shared.buf[shared.out];
shared.out = (shared.out+1)%BUFF_SIZE;
printf("[C%d] Consuming  %d ...\n", index, item);
fflush(stdout);
/* Release the buffer */
pthread_mutex_unlock(&shared.mutex);
/* Increment the number of full slots */
sem_post(&shared.empty);
/* Interleave  producer and consumer execution */
if (i % 2 == 1) sleep(1);
}
return NULL;
}
int main()
{
pthread_t idP, idC;
int index;
sem_init(&shared.full, 0, 0);
sem_init(&shared.empty, 0, BUFF_SIZE);
pthread_mutex_init(&shared.mutex, NULL);
for (index = 0; index < NP; index++)
{
/* Create a new producer */
pthread_create(&idP, NULL, Producer, (void*)index);
}
/*create a new Consumer*/
for(index=0; index<NC; index++)
{
pthread_create(&idC, NULL, Consumer, (void*)index);
}
pthread_exit(NULL);
}

J'espère que cette aide.

Son fonctionnement.Mais pourquoi il ne fonctionne pas si l'on place sem_wait(&partagé.mutex) et sem_post(&partagé.mutex); au lieu de pthread_mutex_lock(&partagé.mutex); et pthread_mutex_unlock(&partagé.mutex);???Veuillez expliquer.
Vous devez décider si vous utiliser un sémaphore ou mutex, alors vous devez utiliser sem_init au lieu de pthread_mutex_init et devraient définir la valeur initiale de 1, comme wait_sem diminue la valeur du sémaphore, si la Valeur est > 0 sinon il bloque jusqu'à ce que la Valeur est > 0. Ce qui n'arrive jamais.

InformationsquelleAutor user2859193

1

Il y a encore des avertissements du compilateur. La bonne façon d'obtenir la valeur de l'entier à partir d'un pointeur void est:
```
index = *(int*)arg;
```
Et, également de passer un pointeur entier, est ci-dessous:
```
pthread_create(&idC,NULL,Consumer,(void*)&index);
```
J'ai encore quelques doutes quant à la façon dont le Consommateur ou le Producteur thread va recevoir la valeur entière, car c'est une adresse de la variable d'index dans le for boucle dans le thread principal. Dès que l'indice est incrémenté, le Consommateur ou le Producteur fil est affecté par cette augmentation.

InformationsquelleAutor typelogic

Vous devez vous connecter pour publier un commentaire.