begin process at 2012 02 07 10:46:27
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Applications Linux

 > THREADS SOUS LINUX

THREADS SOUS LINUX


 Information sur la source

Note :
5,5 / 10 - par 2 personnes
5,50 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
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é :15 258 / 605

Auteur : jsonor

Ecrire un message privé
Site perso
Commentaire sur cette source (7)
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

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

Source avec Zip REQUÊTE SUR UN SERVEUR MYSQL

 Sources de la même categorie

Source avec une capture COLORIMÈTRE NUMÉRIQUE LINUX par valchek
Source avec Zip TRAITEMENTS D'IMAGES AU FORMAT PGM AVEC LES ALGORITHMES DE C... par lemout
Source avec Zip ALGORITHME ACO INTERFACE GTK par RyBeN
Source avec Zip COMPRESSER SES SAUVEGARDES SMSBACKUPRESTORE (ANDROID) EN C A... par ThalLab
SIMPLE SCANNER DE PORTS par Vb6Malade

Commentaires et avis

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 ?

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 =)

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.

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)

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 ?

Commentaire de ckouckou83 le 06/04/2009 15:58:36 1/10

Il manque le  fichier thread.h

Commentaire de LiaGalanodel le 01/04/2010 17:01:51 10/10

Merci ;)

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

Photothèque

 
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

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,123 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales