Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

THREADS SOUS LINUX


Information sur la source

Catégorie :Applications Linux Niveau : Débutant Date de création : 08/01/2004 Date de mise à jour : 13/01/2004 01:24:07 Vu / téléchargé: 12 094 / 548

Note :
1 / 10 - par 1 personne
1,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (6)
Ajouter un commentaire et/ou une note

Description

Ce code montre très simplement comment utiliser des threads sous linux.
Pour compiler la source, il faut linker avec la librairie "pthread" soit :
g++ thread.cpp -o thread -lpthread
Vous pouvez utiliser gcc mais dans ce cas, il faut remplacer le "new char" par un "malloc"...

Mise à jour le 13/01/04 :
Rajout de l'utilisation de mutex et de pthread_join. Avis aux amateurs ;)
Rajout de la source en zip.
 

Source

  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <pthread.h>
  • #include <unistd.h> // pour sleep
  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <pthread.h>
  • // mutex => MUtuelle EXclusion (permet d'éviter un accès simultané à une variable)
  • static pthread_mutex_t mutex;
  • static int tab[5];
  • void* threadLectureTableau(void* arg)
  • {
  • for (int i = 0 ; i != 5 ; i++)
  • {
  • // blocage du mutex
  • // (attente éventuelle de sa libération s'il est déjà bloqué)
  • pthread_mutex_lock (&mutex);
  • printf ("Lecture du tableau 1 : tab[%d] vaut %d\\n", i, tab[i]);
  • // déblocage du mutex
  • pthread_mutex_unlock (&mutex);
  • sleep(1);
  • }
  • pthread_exit (0);
  • }
  • void* threadLectureTableau2(void* arg)
  • {
  • for (int i = 0 ; i != 5 ; i++)
  • {
  • // blocage du mutex
  • // (attente éventuelle de sa libération s'il est déjà bloqué)
  • pthread_mutex_lock (&mutex);
  • printf ("Lecture du tableau 2 : tab[%d] vaut %d\\n", i, tab[i]);
  • // déblocage du mutex
  • pthread_mutex_unlock (&mutex);
  • sleep(2);
  • }
  • pthread_exit (0);
  • }
  • void* threadEcritureTableau(void* arg)
  • {
  • // blocage du mutex
  • // (attente éventuelle de sa libération s'il est déjà bloqué)
  • pthread_mutex_lock (&mutex);
  • for (int i = 0 ; i != 5 ; i++)
  • {
  • tab[i] = 2 * i;
  • printf ("Ecriture du tableau : tab[%d] vaut %d\\n", i, tab[i]);
  • sleep(1);
  • }
  • // déblocage du mutex
  • pthread_mutex_unlock (&mutex);
  • pthread_exit (0);
  • }
  • int main(int argc, char *argv[])
  • {
  • pthread_t thread1, thread2, thread3;
  • void *retour;
  • pthread_mutex_init (&mutex, NULL);
  • if (pthread_create (&thread1, NULL, threadEcritureTableau, NULL) < 0)
  • {
  • fprintf (stderr, "Impossible de créer le thread 1\\n");
  • exit (1);
  • }
  • if (pthread_create (&thread2, NULL, threadLectureTableau, NULL) < 0)
  • {
  • fprintf (stderr, "Impossible de créer le thread 2\\n");
  • exit (1);
  • }
  • if (pthread_create (&thread3, NULL, threadLectureTableau2, NULL) < 0)
  • {
  • fprintf (stderr, "Impossible de créer le thread 2\\n");
  • exit (1);
  • }
  • // le processus principale est ainsi contraint d'attendre la fin d'exécution
  • // des threads fils
  • (void)pthread_join (thread1, &retour);
  • (void)pthread_join (thread2, &retour);
  • (void)pthread_join (thread3, &retour);
  • }
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>	// pour sleep
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// mutex => MUtuelle EXclusion (permet d'éviter un accès simultané à une variable)
static pthread_mutex_t mutex; 
static int tab[5];


void* threadLectureTableau(void* arg)
{
	for (int i = 0 ; i != 5 ; i++)
	{
		// blocage du mutex
		// (attente éventuelle de sa libération s'il est déjà bloqué)
		pthread_mutex_lock (&mutex);

		printf ("Lecture du tableau 1 : tab[%d] vaut %d\\n", i, tab[i]);

		// déblocage du mutex
		pthread_mutex_unlock (&mutex);

		sleep(1);
	}

	pthread_exit (0);
}


void* threadLectureTableau2(void* arg)
{
	for (int i = 0 ; i != 5 ; i++)
	{
		// blocage du mutex
		// (attente éventuelle de sa libération s'il est déjà bloqué)
		pthread_mutex_lock (&mutex);

		printf ("Lecture du tableau 2 : tab[%d] vaut %d\\n", i, tab[i]);

		// déblocage du mutex
		pthread_mutex_unlock (&mutex);

		sleep(2);
	}

	pthread_exit (0);
}


void* threadEcritureTableau(void* arg)
{
	// blocage du mutex
	// (attente éventuelle de sa libération s'il est déjà bloqué)
	pthread_mutex_lock (&mutex);

	for (int i = 0 ; i != 5 ; i++)
	{
		tab[i] = 2 * i;
		printf ("Ecriture du tableau : tab[%d] vaut %d\\n", i, tab[i]);
		sleep(1);
	}

	// déblocage du mutex
	pthread_mutex_unlock (&mutex);

	pthread_exit (0);
}


int main(int argc, char *argv[])
{
	pthread_t thread1, thread2, thread3;
	void *retour;

	pthread_mutex_init (&mutex, NULL);

	if (pthread_create (&thread1, NULL, threadEcritureTableau, NULL) < 0)
	{
		fprintf (stderr, "Impossible de créer le thread 1\\n");
		exit (1);
	}

	if (pthread_create (&thread2, NULL, threadLectureTableau, NULL) < 0)
	{
		fprintf (stderr, "Impossible de créer le thread 2\\n");
		exit (1);
	}

	if (pthread_create (&thread3, NULL, threadLectureTableau2, NULL) < 0)
	{
		fprintf (stderr, "Impossible de créer le thread 2\\n");
		exit (1);
	}

                // le processus principale est ainsi contraint d'attendre la fin d'exécution
                // des threads fils
	(void)pthread_join (thread1, &retour);
	(void)pthread_join (thread2, &retour);
	(void)pthread_join (thread3, &retour);
}

Conclusion

Voilà, j'ai étoffé un peu le code, à la demande de certains, montrant ainsi une nouvelle notion très importante dans la gestion en temps réel, les mutex.

 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

Commentaires et avis

signaler à un administrateur
Commentaire de BlackGoddess le 12/01/2004 10:48:41

pas mal, mais au lieu d'utiliser des usleep tu aurais p-e pu donner un exemple de pthread_join ?

signaler à un administrateur
Commentaire de Thaeron le 13/01/2004 00:43:05

Tu crée les threads mais il n'y a pas d'appel a pthread_join ni a pthread_detach. Sinon sympas, mais étoffe un peu plus ça serai bien =)

signaler à un administrateur
Commentaire de jsonor le 13/01/2004 01:43:36

Voilà, j'ai étoffé un peu le code, montrant en plus une nouvelle notion très importante dans la gestion en temps réel, les mutex.

@bientôt et n'hésitez pas pour d'éventuelles questions...
Jérôme.

signaler à un administrateur
Commentaire de BlackGoddess le 13/01/2004 09:34:47

(pour ceux qui veulent du multithreading portable en c++, cf boost::thread www.boost.org)

signaler à un administrateur
Commentaire de NaarGuileh le 16/09/2004 09:12:31

Intéressant, en BTS IRIS les profs ne nous fait voir que les threads sour windows en nous disant que sous linux ça fonctionnait dans le même esprit.
L'exemple que tu donne confirme et en plus sa structure ressemble en gros à ce que j'avais pu voir.
Mais au niveau des évenements, comment ca marche sous linux ?

signaler à un administrateur
Commentaire de ckouckou83 le 06/04/2009 15:58:36 1/10

Il manque le  fichier thread.h

Ajouter un commentaire



Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Comparez les prix Nouvelle version

Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,468 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.