System programmateur consomateur sous unix

Soyez le premier à donner votre avis sur cette source.

Snippet vu 6 665 fois - Téléchargée 33 fois

Contenu du snippet

/ Un processus produit une valeur entiere toutes les secondes (tache prod) ///
// Un processus lit la valeur quand elle est disponible (tache conso) ///
// Un processus affiche en permanence la valeur (tache affiche) ///
// (en fait 5x par seconde, pour pouvoir placer un RC) ///
// Utilisation sémaphore POSIX. ///

Source / Exemple :


//-------------------------------------------------------------------------------------------------
# include <iostream.h>

# include <stdlib.h>

# include <stdio.h>

# include <unistd.h>

# include <pthread.h>			//librairie POSIX

# include <ctype.h>

# include <sys/types.h>

# include <sys/ipc.h>

# include <sys/shm.h>

# include <sys/sem.h>

# include <sys/wait.h>

# include <signal.h>
//-------------------------------------------------------------------------------------------------
const int CLEF = 2000;

int valeur;				// Variable "globale" pour les valeurs entières à générer

void *producteur(void *p); 		// Tache de production

void *consommateur(void *p);		// Tache de consommation

void *affiche(void *p);			// Tache d'affichage

void *ressources(void *p);		// Tache de creation des ressources

void *nettoyage(void *p);			// Tache de liberation des ressources

//-------------------------------------------------------------------------------------------------
int main(void)

{

// Identifiants des processus

int ress, prod, conso, aff, net;

pthread_t re;				//déclaration de type pthread_t avec identifiant correspondant
pthread_t pro;
pthread_t cons;
pthread_t af;
pthread_t nett;
pthread_mutex_t sem1;			//sémaphore par défaut : "rapide"

char c;

cout << "\nQ pour sortir...\n";

// création des ressources:

if (!(ress=pthread_create(&re, NULL, ressources, NULL)));pthread_detach(re);

wait(NULL);	// Attendre que les ressources soient disponibles

// Les taches tournent en boucle infinie, ce qui permet cette syntaxe:

if (!(prod=pthread_create(&pro, NULL, producteur, NULL)));pthread_detach(pro);
if (!(conso=pthread_create(&cons, NULL, consommateur, NULL)));pthread_detach(cons);
if (!(aff=pthread_create(&af, NULL, affiche, NULL)));pthread_detach(af);

for (;;) {

	if (toupper(getchar())=='Q') break;

	}

cout<<"On arrete tout !!!\n";

//Arret des processus:

kill(prod,9);

kill(conso,9);

kill(aff,9);

cout <<"liberation sema\n";

// Liberation des ressources:
net=pthread_create(&nett, NULL, nettoyage, NULL);pthread_detach(nett);
//nettoyage();

cout <<"fin main\n";

exit(0);

}

//-------------------------------------------------------------------------------------------------
void *producteur(void *p)

{

pthread_mutex_t sem1;			//sémaphore par défaut : "rapide"

for (;;)

	{
        pthread_mutex_lock(&sem1);
	// prod:

	valeur=random();		//génération de la valeur aléatoire

   	pthread_mutex_unlock(&sem1);	//V(s)

	}

}

//-------------------------------------------------------------------------------------------------
void *consommateur(void *p)

{

pthread_mutex_t sem1;

for (;;)

	{ 				//lecture de la valeur
        

	cout <<"\n\tvaleur = "<<valeur<<"      "<<endl;

        pthread_mutex_lock(&sem1);
                
        // prod:

//attente d'une seconde

        sleep(1);
               				//P(s)
        pthread_mutex_unlock(&sem1);

        }
  	
}

//-------------------------------------------------------------------------------------------------
void *affiche(void*p)

{
int i=0;

for (;;)				//affiche la valeur générée toute les secondes

	{

	// prod:

	cout <<"\r"<<i++<<"< "<<valeur<<" > \n";

        //printf("\r%i< %i > \r",i++, valeur);

	usleep(200000);

	}

}

//-------------------------------------------------------------------------------------------------
void *ressources(void *p)

{

pthread_mutex_t sem1;

pthread_mutex_init(&sem1,NULL);			//semaphore rapide (binaire)

cout <<"\nMemoire et semaphore créés\n";

}

//-------------------------------------------------------------------------------------------------
void *nettoyage(void *p)

{

pthread_mutex_t sem1;

pthread_mutex_destroy(&sem1);			//détruit attend libération sem1

}

A voir également

Ajouter un commentaire Commentaire
Messages postés
49
Date d'inscription
mercredi 12 février 2003
Statut
Membre
Dernière intervention
5 septembre 2006

Super !!!!
Tout simplement génial...merci bcp pour ce source car ya vraiment pas bcp de sources sur linux concernant les threads et mutex....
J'ai pas encore essayé, mais ca a l'air tout simplement un bijoux !!!

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.