Syncronization dans des threads POSIX en utilisant un fil

A+ A-

La synchronisation de fil est une partie importante de System.It d'exploitation est en expliquant que threads ou processus concurremment-exécution n'exécutent des parties spécifiques d'un programme en même temps. Si un thread a commencé à exécuter une partie sérialisée du programme, tout autre thread tente d'exécuter cette partie doit attendre jusqu'à ce que les premières finitions de fil.

En général, la partie serialize du programme est appelé comme section critique, signifie que si un thread est en cours d'exécution dans sa section critique signifie qu'aucun autre thread ne sont autorisés à entrer dans leur section critique. Il existe différentes techniques de synchronisation de processus / de fil disponible en C ++

  • Verrouillage

  • Mutex

  • Moniteur (synchronisation)

  • Sémaphore

Voici une méthode de mutex d'exemple fil de synchronisation à l'aide C ++

// Synchronisation des threads
#comprendre 
#comprendre 
#comprendre 
#comprendre 
#comprendre 
using namespace std;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

void * redacteur1 (void fd *)
{
   int * f = (int *) fd;
   char * string1 = new char [200];
   pthread_mutex_lock (& ​​m);
   Cout << "\ n entrer 1er éléments de fil à écrire dans le fichier";
   gets (string1);
   for (int i = 0; i <= strlen (chaîne_1); i ++)
   {
      écrire (f, & string1 [i], 1);
      sommeil (1);
   }
   pthread_mutex_unlock (& ​​m);
}
void * redacteur2 (void fd *)
{
   int * f = (int *) fd;
   char * string2 = new char [200];
   pthread_mutex_lock (& ​​m);
   Cout << "\ n enter enter deuxièmes éléments de fil à écrire dans le fichier";
   gets (string2);
   for (int i = 0; i <= strlen (chaîne2); i ++)
   {
      écrire (f, & chaîne2 [i], 1);
      sommeil (1);
   }
   pthread_mutex_unlock (& ​​m);
}
Principal()
{
   pthread_t t1, t2;
   int fd = open ( "file.txt", O_CREAT | O_RDWR | O_APPEND);
   pthread_create (& t1,0, redacteur1, & fd);
   pthread_create (& t2,0, redacteur2, & fd);
   pthread_join (t1,0);
   pthread_join (t2,0);
}

A propos de SourceCode

  • pthread_create (), pthread_join () sont deux fonctions de bibliothèque pour créer le fil et l'attente pour le fil simultanément.

  • pthread_mutex_t est utilisé pour déclarer la variable mutex.

  • PTHREAD_MUTEX_INITIALIZER est utilisé pour initialiser un mutex statique.

  • Ici, nous faisons de verrouillage en utilisant la fonction pthread_mutex_lock (pthread_mutex_t *) fichier et déverrouillage en utilisant la fonction pthread_mutex_unlock (pthread_mutex_t *).

  • L'objectif principal de ce code source est d'écrire dans un fichier d'une manière de synchronisation.

Champ d'application

  • Transaction bancaire

  • Système de base de données

  • Serveurs Web

  • Design Multithreading OS