Comment : gérer une instance de planificateur
Les instances du planificateur vous permettent d'associer des stratégies de planification spécifiques à différents genres de charges de travail.Cette rubrique contient deux exemples de base qui indiquent comment créer et gérer une instance du planificateur.
Les exemples créent des planificateurs qui utilisent les stratégies du 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.
Pour gérer une instance du planificateur dans votre application
Créer un concurrency::SchedulerPolicy objet qui contient la stratégie des valeurs à utiliser le Planificateur.
Appelez le concurrency::CurrentScheduler::Create méthode ou la concurrency::Scheduler::Create méthode pour créer une instance du Planificateur.
Si vous utilisez le Scheduler::Create méthode, appelez le concurrency::Scheduler::Attach méthode lorsque vous devez associer le planificateur du contexte actuel.
Appelez la fonction CreateEvent pour créer un handle vers un objet événement à réinitialisation automatique non signalé.
Passer le handle de l'objet d'événement que vous venez de créer à le concurrency::CurrentScheduler::RegisterShutdownEvent méthode ou la concurrency::Scheduler::RegisterShutdownEvent méthode.Cela enregistre l'événement à définir lors de la destruction du planificateur.
Effectuez les tâches que vous voulez que le planificateur actuel planifie.
Appelez le concurrency::CurrentScheduler::Detach méthode pour détacher le planificateur en cours et de restaurer le Planificateur précédent que celle en cours.
Si vous utilisez le Scheduler::Create méthode, appelez le concurrency::Scheduler::Release méthode décrémente le décompte de références de la Scheduler objet.
Passez le handle vers l'événement à la fonction WaitForSingleObject pour attendre que le planificateur s'arrête.
Appelez la fonction CloseHandle pour fermer le handle vers l'objet événement.
Exemple
Le code suivant illustre deux manières de gérer une instance du 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 du planificateur pour effectuer de nouveau la même tâche.Pour finir, chaque exemple restaure le planificateur par défaut comme planificateur actuel et exécute la tâche une fois de plus.
Le premier exemple utilise la concurrency::CurrentScheduler classe pour créer une instance du Planificateur et l'associer avec le contexte actuel.Le deuxième exemple utilise la concurrency::Scheduler classe pour effectuer la même tâche.En général, la classe CurrentScheduler s'utilise avec le planificateur actuel.Le deuxième exemple, qui utilise la classe Scheduler, est utile lorsque vous voulez contrôler le moment où le planificateur est associé au contexte actuel ou lorsque vous voulez 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 génère 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, collez-le dans un projet Visual Studio et collez-le dans un fichier nommé scheduler-instance.cpp , puis exécutez la commande suivante dans une fenêtre d'invite de commande Visual Studio.
cl.exe /EHsc scheduler-instance.cpp
Voir aussi
Tâches
Comment : spécifier des stratégies de planificateur