Comment : gérer une instance de planificateur

Article
10/12/2023

Les instances du planificateur vous permettent d’associer des stratégies de planification spécifiques à différents types de charges de travail. Cette rubrique contient deux exemples de base qui montrent comment créer et gérer une instance de planificateur.

Les exemples créent des planificateurs qui utilisent les stratégies de planificateur par défaut. Pour obtenir un exemple qui crée un planificateur qui utilise une stratégie personnalisée, consultez Comment : spécifier des stratégies de planificateur spécifiques.

Pour gérer une instance de planificateur dans votre application

Créez un objet concurrency ::SchedulerPolicy qui contient les valeurs de stratégie que le planificateur doit utiliser.
Appelez la méthode concurrency ::CurrentScheduler ::Create ou concurrency ::Scheduler ::Create pour créer une instance de planificateur.

Si vous utilisez la Scheduler::Create méthode, appelez la méthode concurrency ::Scheduler ::Attach lorsque vous devez associer le planificateur au contexte actuel.
Appelez la fonction CreateEvent pour créer un handle à un objet d’événement de réinitialisation automatique non signalé.
Passez le handle à l’objet d’événement que vous venez de créer à la méthode concurrency ::CurrentScheduler ::RegisterShutdownEvent ou à la méthode concurrency ::Scheduler ::RegisterShutdownEvent . Cela enregistre l’événement à définir lorsque le planificateur est détruit.
Effectuez les tâches que vous souhaitez que le planificateur actuel planifie.
Appelez la méthode concurrency ::CurrentScheduler ::D etach pour détacher le planificateur actuel et restaurer le planificateur précédent en tant que planificateur actuel.

Si vous utilisez la Scheduler::Create méthode, appelez la méthode concurrency ::Scheduler ::Release pour décrémenter le nombre de références de l’objet Scheduler .
Passez le handle à l’événement à la fonction WaitForSingleObject pour attendre que le planificateur s’arrête.
Appelez la fonction CloseHandle pour fermer le handle de l’objet d’événement.

Exemple

Le code suivant montre deux façons de gérer une instance de planificateur. Chaque exemple utilise d’abord le planificateur par défaut pour effectuer une tâche qui imprime l’identificateur unique du planificateur actuel. Chaque exemple utilise ensuite une instance de planificateur pour effectuer à nouveau la même tâche. Enfin, chaque exemple restaure le planificateur par défaut en tant que planificateur actuel et effectue la tâche une fois de plus.

Le premier exemple utilise la classe concurrency ::CurrentScheduler pour créer une instance de planificateur et l’associer au contexte actuel. Le deuxième exemple utilise la classe concurrency ::Scheduler pour effectuer la même tâche. En règle générale, la CurrentScheduler classe est utilisée pour travailler avec le planificateur actuel. Le deuxième exemple, qui utilise la Scheduler classe, est utile lorsque vous souhaitez contrôler quand le planificateur est associé au contexte actuel ou lorsque vous souhaitez associer des planificateurs spécifiques à des tâches spécifiques.

// scheduler-instance.cpp
// compile with: /EHsc
#include <windows.h>
#include <ppl.h>
#include <iostream>

using namespace concurrency;
using namespace std;

// Prints the identifier of the current scheduler to the console.
void perform_task()
{
   // A task group.
   task_group tasks;

   // Run a task in the group. The current scheduler schedules the task.
   tasks.run_and_wait([] { 
      wcout << L"Current scheduler id: " << CurrentScheduler::Id() << endl;
   });
}

// Uses the CurrentScheduler class to manage a scheduler instance.
void current_scheduler()
{
   // Run the task.
   // This prints the identifier of the default scheduler.
   perform_task();

   // For demonstration, create a scheduler object that uses 
   // the default policy values.
   wcout << L"Creating and attaching scheduler..." << endl;
   CurrentScheduler::Create(SchedulerPolicy());

   // Register to be notified when the scheduler shuts down.
   HANDLE hShutdownEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   CurrentScheduler::RegisterShutdownEvent(hShutdownEvent);

   // Run the task again.
   // This prints the identifier of the new scheduler.
   perform_task();

   // Detach the current scheduler. This restores the previous scheduler
   // as the current one.
   wcout << L"Detaching scheduler..." << endl;
   CurrentScheduler::Detach();

   // Wait for the scheduler to shut down and destroy itself.
   WaitForSingleObject(hShutdownEvent, INFINITE);

   // Close the event handle.
   CloseHandle(hShutdownEvent);

   // Run the sample task again.
   // This prints the identifier of the default scheduler.
   perform_task();
}

// Uses the Scheduler class to manage a scheduler instance.
void explicit_scheduler()
{
   // Run the task.
   // This prints the identifier of the default scheduler.
   perform_task();

   // For demonstration, create a scheduler object that uses 
   // the default policy values.
   wcout << L"Creating scheduler..." << endl;
   Scheduler* scheduler = Scheduler::Create(SchedulerPolicy());

   // Register to be notified when the scheduler shuts down.
   HANDLE hShutdownEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   scheduler->RegisterShutdownEvent(hShutdownEvent);

   // Associate the scheduler with the current thread.
   wcout << L"Attaching scheduler..." << endl;
   scheduler->Attach();

   // Run the sample task again.
   // This prints the identifier of the new scheduler.
   perform_task();

   // Detach the current scheduler. This restores the previous scheduler
   // as the current one.
   wcout << L"Detaching scheduler..." << endl;
   CurrentScheduler::Detach();

   // Release the final reference to the scheduler. This causes the scheduler
   // to shut down after all tasks finish.
   scheduler->Release();

   // Wait for the scheduler to shut down and destroy itself.
   WaitForSingleObject(hShutdownEvent, INFINITE);

   // Close the event handle.
   CloseHandle(hShutdownEvent);

   // Run the sample task again.
   // This prints the identifier of the default scheduler.
   perform_task();
}

int wmain()
{
   // Use the CurrentScheduler class to manage a scheduler instance.
   wcout << L"Using CurrentScheduler class..." << endl << endl;
   current_scheduler();

   wcout << endl << endl;

   // Use the Scheduler class to manage a scheduler instance.
   wcout << L"Using Scheduler class..." << endl << endl;
   explicit_scheduler();
}

Cet exemple produit la sortie suivante.

Using CurrentScheduler class...

Current scheduler id: 0
Creating and attaching scheduler...
Current scheduler id: 1
Detaching scheduler...
Current scheduler id: 0

Using Scheduler class...

Current scheduler id: 0
Creating scheduler...
Attaching scheduler...
Current scheduler id: 2
Detaching scheduler...
Current scheduler id: 0

Compilation du code

Copiez l’exemple de code et collez-le dans un projet Visual Studio, ou collez-le dans un fichier nommé scheduler-instance.cpp , puis exécutez la commande suivante dans une fenêtre d’invite de commandes Visual Studio.

cl.exe /EHsc scheduler-instance.cpp

Voir aussi

Instances de planificateur
Guide pratique pour spécifier des stratégies de planificateur

Partager via