Cómo: Administrar una instancia del programador
Las instancias del Programador permiten asociar directivas de programación concretas con varios tipos de cargas de trabajo.Este tema contiene dos ejemplos básicos que muestran cómo crear y administrar una instancia del programador.
En los ejemplos se crean programadores que usan las directivas del programador predeterminado.Para obtener un ejemplo donde se crea un programador que usa una directiva personalizada, vea Cómo: Especificar directivas de programador concretas.
Para administrar una instancia del programador en su aplicación
Crear un concurrency::SchedulerPolicy los valores de objeto que contiene la directiva para que el programador de tareas utilizar.
Llame a la concurrency::CurrentScheduler::Create método o la concurrency::Scheduler::Create método para crear una instancia de programador.
Si utiliza la Scheduler::Create método, llamada la concurrency::Scheduler::Attach método cuando es necesario asociar el programador con el contexto actual.
Llame a la función CreateEvent para crear un controlador para un objeto de evento de restablecimiento automático no señalado.
Pasar el identificador para el objeto de evento que acaba de crear para el concurrency::CurrentScheduler::RegisterShutdownEvent método o la concurrency::Scheduler::RegisterShutdownEvent método.De esta forma se registra el evento que se debe establecer cuando se destruya el programador.
Realice las tareas que desea que programe el programador actual.
Llame a la concurrency::CurrentScheduler::Detach método para separar el programador actual y restaurar el programador anterior como el actual.
Si utiliza la Scheduler::Create método, llamada la concurrency::Scheduler::Release método para reducir el recuento de referencia de la Scheduler objeto.
Pase el controlador del evento a la función WaitForSingleObject para esperar a que el programador se cierre.
Llame a la función CloseHandle para cerrar el controlador del objeto de evento.
Ejemplo
En el siguiente código se muestran dos maneras de administrar una instancia del programador.En cada ejemplo se usa primero el programador predeterminado para realizar una tarea que imprima el identificador único del programador actual.A continuación, se usa una instancia del programador para realizar la misma tarea de nuevo.Finalmente, en cada ejemplo se restaura el programador predeterminado como el actual y se realiza la tarea una vez más.
El primer ejemplo se utiliza la concurrency::CurrentScheduler clase para crear una instancia de programador y asociarlo con el contexto actual.El segundo ejemplo utiliza la concurrency::Scheduler clase para realizar la misma tarea.Normalmente, la clase CurrentScheduler se usa con el programador actual.El segundo ejemplo, que usa la clase Scheduler, es útil si se desea controlar cuándo está asociado el programador al contexto actual o si se desea asociar programadores concretos a tareas concretas.
// 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();
}
Este ejemplo produce el siguiente resultado.
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
Compilar el código
Copie el código de ejemplo y péguelo en un proyecto de Visual Studio o lo pega en un archivo denominado instance.cpp-programador de y, a continuación, ejecute el siguiente comando en una ventana de símbolo del sistema de Visual Studio.
cl.exe /EHsc scheduler-instance.cpp
Vea también
Tareas
Cómo: Especificar directivas de programador concretas