Instancias de Scheduler
En este documento se describe el rol de las instancias del programador en el Runtime de simultaneidad y cómo usar las clases concurrency::Scheduler y concurrency::CurrentScheduler para crear y administrar instancias del programador. Las instancias del programador son útiles para asociar directivas de programación explícitas con tipos concretos de cargas de trabajo. Por ejemplo, puede crear una instancia de programador para ejecutar algunas tareas con una prioridad elevada de subproceso y usar el programador predeterminado para ejecutar con otras tareas con la prioridad normal de subproceso.
Sugerencia
Runtime de simultaneidad proporciona un programador predeterminado, por lo que no deberá crear uno en la aplicación. El Programador de tareas permite ajustar el rendimiento de las aplicaciones por lo que, si no está familiarizado con Runtime de simultaneidad, se recomienda comenzar con la biblioteca de modelos paralelos (PPL) o la biblioteca de agentes asincrónicos.
Secciones
Las clases Scheduler y CurrentScheduler
El Programador de tareas permite a las aplicaciones usar una o varias instancias del programador para programar el trabajo. La clase concurrency::Scheduler representa una instancia del programador y encapsula la funcionalidad relacionada con las tareas de programación.
Un subproceso asociado a un programador se conoce como contexto de ejecución o, simplemente, contexto. Un programador puede estar activo en el contexto actual en cualquier momento. El programador activo también se conoce como programador actual. El Runtime de simultaneidad usa la clase concurrency::CurrentScheduler para proporcionar acceso al programador actual. El programador actual de un contexto puede diferir del programador actual para otro contexto. El tiempo de ejecución no proporciona una representación de nivel de proceso del programador actual.
Normalmente, la clase CurrentScheduler se usa para acceder al programador actual. La clase Scheduler es útil cuando necesita administrar un programador que no es el actual.
En las secciones siguientes se describe cómo crear y administrar una instancia del programador. Para obtener un ejemplo completo que ilustra estas tareas, consulte Cómo administrar una instancia del programador.
[Arriba]
Creación una instancia del programador
Existen tres maneras de crear un objeto Scheduler:
Si no existe ningún programador, el tiempo de ejecución crea un programador predeterminado para usted cuando se usa la funcionalidad en tiempo de ejecución, por ejemplo, un algoritmo paralelo, para realizar el trabajo. El programador predeterminado se convierte en el programador actual para el contexto que inicia el trabajo paralelo.
El método concurrency::CurrentScheduler::Create crea un objeto
Schedulerque usa una directiva específica y asocia ese programador con el contexto actual.El método concurrency::Scheduler::Create crea un objeto
Schedulerque usa una directiva específica, pero no lo asocia al contexto actual.
Permitir que el tiempo de ejecución cree un programador predeterminado permite que todas las tareas simultáneas compartan el mismo programador. Normalmente, la funcionalidad proporcionada por la biblioteca de patrones paralelos (PPL) o la biblioteca de agentes asincrónicos se usa para realizar un trabajo paralelo. Por lo tanto, no es necesario trabajar directamente con el programador para controlar su directiva o duración. Cuando se usa PPL o la Biblioteca de agentes, el tiempo de ejecución crea el programador predeterminado si no existe y lo convierte en el programador actual para cada contexto. Cuando se crea un programador y se establece como el programador actual, el tiempo de ejecución usa ese programador para programar tareas. Cree instancias adicionales del programador solo cuando necesite una directiva de programación específica. Para obtener más información sobre las directivas asociadas a un programador, vea Directivas del programador.
[Arriba]
Administración de la duración de una instancia del programador
El tiempo de ejecución usa un mecanismo de recuento de referencias para controlar la duración de los objetos Scheduler.
Cuando se usa el método CurrentScheduler::Create o el método Scheduler::Create para crear un objeto Scheduler, el tiempo de ejecución establece el recuento de referencia inicial de ese programador en uno. El tiempo de ejecución incrementa el recuento de referencias al llamar al método concurrency::Scheduler::Attach . El método Scheduler::Attach asocia el objeto Scheduler junto con el contexto actual. Esto lo convierte en el programador actual. Cuando se llama al método CurrentScheduler::Create, el tiempo de ejecución crea un objeto Scheduler y lo adjunta al contexto actual (y establece el recuento de referencias en uno). También puede usar el método concurrency::Scheduler::Reference para incrementar el recuento de referencias de un objeto Scheduler.
El tiempo de ejecución disminuye el recuento de referencias al llamar al método concurrency::CurrentScheduler::Detach para desasociar el programador actual o llamar al método concurrency::Scheduler::Release. Cuando el recuento de referencias alcanza cero, el tiempo de ejecución destruye el objeto Scheduler una vez finalizadas todas las tareas programadas. Se permite que una tarea en ejecución incremente el recuento de referencias del programador actual. Por lo tanto, si el recuento de referencias alcanza cero y una tarea incrementa el recuento de referencias, el tiempo de ejecución no destruye el objeto Scheduler hasta que el recuento de referencias alcanza de nuevo cero y todas las tareas finalizan.
El tiempo de ejecución mantiene una pila interna de objetos Scheduler para cada contexto. Cuando se llama al método Scheduler::Attach o CurrentScheduler::Create, el tiempo de ejecución inserta ese objeto Scheduler en la pila para el contexto actual. Esto lo convierte en el programador actual. Cuando se llama a CurrentScheduler::Detach, el tiempo de ejecución extrae el programador actual de la pila para el contexto actual y establece el anterior como el programador actual.
El tiempo de ejecución proporciona varias maneras de administrar la duración de una instancia del programador. En la tabla siguiente se muestra el método adecuado que libera o desasocia el programador del contexto actual para cada método que crea o asocia un programador al contexto actual.
| Crear o adjuntar método | Método de liberación o desasociación |
|---|---|
CurrentScheduler::Create |
CurrentScheduler::Detach |
Scheduler::Create |
Scheduler::Release |
Scheduler::Attach |
CurrentScheduler::Detach |
Scheduler::Reference |
Scheduler::Release |
Al llamar al método de liberación o desasociación inadecuados, se produce un comportamiento no especificado en el tiempo de ejecución.
Cuando se usa la funcionalidad, por ejemplo, la PPL, que hace que el tiempo de ejecución cree el programador predeterminado para usted, no libere ni desasocie este programador. El tiempo de ejecución administra la duración de cualquier programador que cree.
Dado que el tiempo de ejecución no destruye un objeto Scheduler antes de que finalicen todas las tareas, puede usar el método concurrency::Scheduler::RegisterShutdownEvent o el método concurrency::CurrentScheduler::RegisterShutdownEvent para recibir una notificación cuando se destruye un objeto Scheduler. Esto resulta útil cuando debe esperar a que finalice cada tarea programada por un objeto Scheduler.
[Arriba]
Métodos y características
En esta sección se resumen los métodos importantes de las clases CurrentScheduler y Scheduler.
Piense en la clase CurrentScheduler como un asistente para crear un programador para usarlo en el contexto actual. La clase Scheduler permite controlar un programador que pertenece a otro contexto.
En la tabla siguiente se muestran los métodos importantes definidos por la clase CurrentScheduler.
| Method | Descripción |
|---|---|
| Creación | Crea un objeto Scheduler que usa la directiva especificada y la asocia al contexto actual. |
| Get | Recupera un puntero al objeto Scheduler asociado al contexto actual. Este método no incrementa el recuento de referencias del objeto Scheduler. |
| Separar | Desasocia el programador actual del contexto actual y establece el anterior como programador actual. |
| RegisterShutdownEvent | Registra un evento que el tiempo de ejecución establece cuando se destruye el programador actual. |
| CreateScheduleGroup | Crea un objeto concurrency::ScheduleGroup en el programador actual. |
| ScheduleTask | Agrega una tarea ligera a la cola de programación del programador actual. |
| GetPolicy | Recupera una copia de la directiva asociada al programador actual. |
En la tabla siguiente se muestran los métodos importantes definidos por la clase Scheduler.
| Method | Descripción |
|---|---|
| Creación | Crea un objeto Scheduler que usa la directiva especificada. |
| Adjuntar | Asocia el objeto Scheduler junto con el contexto actual. |
| Referencia | Incrementa el recuento de referencias del objeto Scheduler. |
| Versión | Reduce el recuento de referencias del objeto Scheduler. |
| RegisterShutdownEvent | Registra un evento que el tiempo de ejecución establece cuando se destruye el objeto Scheduler. |
| CreateScheduleGroup | Crea un objeto concurrency::ScheduleGroup en el objeto Scheduler. |
| ScheduleTask | Programa una tarea ligera desde el objeto Scheduler. |
| GetPolicy | Recupera una copia de la directiva asociada al objeto Scheduler. |
| SetDefaultSchedulerPolicy | Establece la directiva para que el tiempo de ejecución se use cuando crea el programador predeterminado. |
| ResetDefaultSchedulerPolicy | Restaura la directiva predeterminada a la que estaba activa antes de la llamada a SetDefaultSchedulerPolicy. Si el programador predeterminado se crea después de esta llamada, el tiempo de ejecución usa la configuración de directiva predeterminada para crear el programador. |
[Arriba]
Ejemplo
Para obtener ejemplos básicos de cómo crear y administrar una instancia del programador, consulte Procedimiento para administrar una instancia del programador.
Consulte también
Programador de tareas
Procedimiento para administrar una instancia de Scheduler
Directivas de Scheduler
Grupos de programación