Ajouter un délai temporisé en C++

1. Utilisez l’appel système sleep() pour ajouter un délai temporisé en C++
2. Utilisez la fonction usleep() pour ajouter un délai temporisé en C++
3. Utilisez la fonction sleep_for() pour ajouter un délai temporisé en C++
4. Utilisez la fonction sleep_until() pour ajouter un délai temporisé en C++

Ce didacticiel vous donnera un bref guide sur l’ajout d’un délai temporisé dans votre programme C++.

Cela peut être fait de plusieurs façons en utilisant certaines fonctions que les bibliothèques C++ nous fournissent. Nous discuterons de certaines fonctions avec leur démonstration de travail.

Tout processus, tâche ou thread dans un programme informatique peut dormir ou devenir inactif. Cela signifie que l’exécution du processus peut être mise en attente pendant le temps qu’il est en sommeil.

Lorsque l’intervalle de veille expire ou qu’un signal ou une interruption entraîne la reprise de l’exécution, l’exécution reprend. Il existe différentes méthodes à cet effet :

1. l’appel système sleep()
2. la méthode usleep()
3. la méthode sleep_for()
4. la méthode sleep_until()

Utilisez l’appel système sleep() pour ajouter un délai temporisé en C++

Un appel système sleep peut mettre un programme (tâche, processus ou thread) en veille. Le paramètre time dans un appel système sleep typique indique combien de temps le programme a besoin pour dormir ou rester inactif.

Le langage C++ n’a pas sa fonction sleep. Cette fonctionnalité est fournie par des fichiers spécifiques au système d’exploitation tels que unistd.h pour Linux et Windows.h pour Windows.

Pour utiliser la fonction sleep() sur un système d’exploitation Linux ou UNIX, nous devons inclure le fichier d’en-tête "unistd.h" dans notre programme.

Prototype de fonction

unsigned sleep(unsigned seconds);

Il prend un paramètre de nombre de secondes pendant lesquelles nous devons suspendre l’exécution et renvoie 0 s’il revient avec succès à l’exécution. Si le sommeil est interrompu entre-temps, le temps total moins le temps d’interruption est renvoyé.

Exemple:

#ifdef _WIN32
#include <Windows.h>
#else
#include <unistd.h>
#endif
#include <cstdlib>
#include <iostream>
using namespace std;

int main() {
  cout << "Before sleep call " << endl;
  cout.flush();
  sleep(9);
  cout << "After sleep call" << endl;

  return 0;
}

Production:

Before sleep call
After sleep call

Dans la sortie, nous avons imprimé deux déclarations. Après avoir imprimé le premier, le compilateur attend 9 secondes, puis l’autre est imprimé. Les lecteurs doivent exécuter le programme pour observer ce délai.

Utilisez la fonction usleep() pour ajouter un délai temporisé en C++

Une autre fonction dans l’en-tête unistd.h est usleep(), qui vous permet de suspendre l’exécution d’un programme pendant une durée définie. Le fonctionnement est identique à la fonction sleep() décrite précédemment.

La fonction usleep() suspend l’exécution du thread appelant pendant usecondes microsecondes ou jusqu’à ce que le signal interrompant l’exécution soit envoyé.

Prototype de fonction

int usleep(useconds_t useconds);

Cette fonction prend comme paramètre le nombre de microsecondes pendant lesquelles vous devez interrompre l’exécution et renvoie 0 si reprise avec succès et -1 si un échec se produit.

Exemple:

#include <unistd.h>

#include <cstdlib>
#include <iostream>
using namespace std;

int main() {
  cout << "Hello ";
  cout.flush();
  usleep(10000);
  cout << "World";
  cout << endl;

  return 0;
}

Production:

Before Usleep Call
After Usleep call

Comme vous pouvez le voir dans l’extrait de code ci-dessus, nous avons fourni une attente de 10 000 microsecondes entre l’impression de deux instructions.

En C++ 11, nous disposons de fonctions spécifiques pour faire dormir les threads. Il existe deux méthodes à cet effet, sleep_for et sleep_until.

Discutons de ces deux méthodes :

Utilisez la fonction sleep_for() pour ajouter un délai temporisé en C++

La fonction sleep_for () est définie dans l’en-tête <thread>. La fonction sleep_for () suspend l’exécution du thread en cours pendant la durée spécifiée dans sleep duration.

En raison d’activités de planification ou de retards de conflit de ressources, cette fonction peut se bloquer plus longtemps que la période indiquée.

Prototype de fonction

template <class Rep, class Period>
void sleep_for(const std::chrono::duration<Rep, Period>& sleep_duration);

Exemple:

#include <chrono>
#include <iostream>
#include <thread>
using namespace std;

int main() {
  cout << "Hello I'm here before waiting" << endl;
  this_thread::sleep_for(chrono::milliseconds(10000));
  cout << "I Waited for 10000 ms\n";
}

Production:

Hello I'm here before waiting
I Waited for 10000 ms

Dans l’extrait de code ci-dessus, nous avons mis le thread principal en veille pendant 10 000 millisecondes, ce qui signifie que le thread actuel bloquera 10 000 millisecondes puis reprendra son exécution.

Utilisez la fonction sleep_until() pour ajouter un délai temporisé en C++

L’en-tête <thread> définit cette fonction. La méthode sleep_until () arrête un thread de s’exécuter jusqu’à ce que le temps de sommeil soit écoulé.

En raison des activités de planification ou des retards de conflit de ressources, cette fonction, comme les autres, peut se bloquer plus longtemps que la durée spécifiée.

Prototype de fonction

template <class Clock, class Duration>
void sleep_until(const std::chrono::time_point<Clock, Duration>& sleep_time);

Il prend en paramètre la période pendant laquelle le thread doit être bloqué et ne renvoie rien.

Exemple:

#include <chrono>
#include <iostream>
#include <thread>
using namespace std;

int main() {
  cout << "Hello I'm here before waiting" << endl;
  std::this_thread::sleep_until(std::chrono::system_clock::now()
                                    std::chrono::seconds(3));
  cout << "I Waited for 3 seconds\n";
}

Production:

Hello I'm here before waiting
I Waited for 2 seconds