Bonjour à tous,
Je suis actuellement en train de développer un petit ordonnanceur ( très simplifié) en C++, sous environnement Eclipse, compilation sous Linux, et je me pose quelques questions d'ordre général que je vous soumets donc, si vous le voulez bien.
1) A quoi servent les boucles while(1) ? Dans pas mal d'exemple de multithreading trouvés sur internet, le dev utilise de telles boucles dans ses threads, mais je n'en vois pas vraiment l'utilité puisqu'une boucle infinie, en théorie, c'est "mal" , non ?
2) Qu'est ce qu'un mutex, je veux dire en pratique ? C'est une sorte de sémaphore, ou alors les sémaphores sont-ils une sorte de mutex ? Il me semble qu'un mutex délivre une instruction au processeur, non ? Je n'arrive pas bien à saisir tous les concepts derrière la notion de thread et ça me bloque un peu pour avancer.
3) J'ai toujours entendu " mettre un using namespace std c'est pas bien" ( contrairement à ce qu'on fait en cours ^^") et ça je crois que c'est pour éviter des collisions si on utilise deux espace contenant des fonctions homonymes, mais j'entends aussi " tout faire dans le main c'est pas bien, il faut utiliser des classes " ( comme ce qu'on fait en cours par contre ) mais ici je ne vois pas comment faire une classe, du coup j'ai déclaré mes thread dans le main, mais j'aimerai savoir s'il existait une solution plus " propre".
4) J'aimerai pour finir savoir s'il existait une réelle différence entre int main() et int main(void). il me semble avoir lu que l'un permettait de surcharger la fonction avec des paramètres et que l'autre non ?
Je joins mon code, si des gens sont intéressés ou ont des commentaire sur la propreté ou l'efficacité ( je débute donc j'ai un peu de mal avec toutes les notions pour l'instant)
Merci beaucoup à ceux qui ont prit le temps de lire, et merci encore à ceux qui prendront le temps de m'éclairer.
Bonne journée !
Includes et déclarations
1 2 3 4 5 6 7 8 9 10 | #include <pthread.h> #include <limits> #include <iostream> #include <string> #include <cstdlib> #include <fstream> pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // on déclare un mutex pthread_cond_t condition = PTHREAD_COND_INITIALIZER; // on déclare la condition |
Mon premier thread :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | void *execution(void *arg) { int nbThread=0; std::string nom; std::ifstream file( "Parametrage_Job.txt" ); // lire le fichier de l'utilisateur if (file) // echec si le fichier n'est pas présent dans le répertoire { int lignes = 0; while (file.ignore(std::numeric_limits <int>::max(), '\n' ) )// 1 ligne = 1 thread : on cherche le nombre de jobs dans le fichier { ++lignes; } nbThread=lignes; } for(int i=0;i<=nbThread;i++) { std::string nom; while ( getline( file, nom)) { std::cout << "Tache " << i << ": " << nom << std::endl; // Problème : rien ne s'affiche sur la console } if (i > nbThread ) { pthread_mutex_lock (&mutex); /* On verrouille le mutex */ pthread_cond_signal (&condition); /* On délivre le signal : condition remplie */ pthread_mutex_unlock (&mutex); /* On déverrouille le mutex */ nbThread=0; } } (void) arg; pthread_exit(NULL); } |
Mon deuxième thread
1 2 3 4 5 6 7 8 9 10 11 12 | void *confirmation(void *arg) { pthread_mutex_lock (&mutex); /* On verrouille le mutex */ pthread_cond_wait( &condition, &mutex); // attendre une condition std::cout << " Toutes vos taches se sont accomplies" << std::endl; pthread_mutex_unlock (&mutex); /* On déverrouille le mutex */ pthread_exit(NULL); } |
Mon main
1 2 3 4 5 6 7 8 9 10 11 12 13 | int main(void) { pthread_t ThreadTache; pthread_t ThreadVerification; pthread_create(&ThreadTache, NULL,execution,NULL); pthread_create(&ThreadVerification, NULL, confirmation,NULL); pthread_join (ThreadTache,NULL); pthread_join (ThreadVerification,NULL); return 0;} |
. D'une part parce que boost nous permettait déjà d'avoir quelque chose de plus C++-ien. Et surtout parce qu'aujourd'hui c'est la bibliothèque standard qui nous le permet.
.
