Contextos
En este documento se describe el rol de los contextos en el runtime de simultaneidad.Un subproceso que se adjunta a un programador se conoce como contexto de ejecución o simplemente contexto.El concurrency::wait función y el concurrency::Context clase permiten controlar el comportamiento de los contextos.Use la función wait para suspender el contexto actual durante un periodo de tiempo especificado.Use la clase Context cuando necesite tener mayor control sobre cuándo los contextos se bloquean, desbloquean y ceden, o sobre cuándo desea suscribir en exceso el contexto actual.
.gif "Sugerencia") Sugerencia |
|---|
El runtime de simultaneidad proporciona un programador predeterminado y, por tanto, no es necesario crear uno en la aplicación.Dado que el programador de tareas ayuda a ajustar el rendimiento de las aplicaciones, se recomienda que comience con Parallel Patterns Library (PPL) o Biblioteca de agentes asincrónicos si no ha usado antes el runtime de simultaneidad. |
La función de espera (wait)
El concurrency::wait función cooperativamente produce la ejecución del contexto actual para un número de milisegundos especificado.El runtime utiliza el tiempo cedido para realizar otras tareas.Una vez transcurrido el tiempo especificado, el runtime reprograma el contexto para la ejecución.Por consiguiente, la función wait podría suspender el contexto actual durante más tiempo que el valor proporcionado para el parámetro milliseconds.
Al pasar 0 (cero) para el parámetro milliseconds, se provoca que el runtime suspenda el contexto actual hasta que se proporcione a todos los demás contextos activos la oportunidad de realizar el trabajo.Esto le permite ceder una tarea a todas las demás tareas activas.
.gif "Ff829266.collapse_all(es-es,VS.110).gif")
Ejemplo
Para obtener un ejemplo que usa la función wait para ceder el contexto actual y permitir que se ejecuten otros contextos, vea Cómo: Usar grupos de programación para influir en el orden de ejecución.
La clase Context
El concurrency::Context clase proporciona una abstracción de programación para un contexto de ejecución y ofrece dos funciones importantes: la capacidad de manera cooperativa bloquear, desbloquear y ceder el contexto actual y la capacidad de explicaré el contexto actual.
Bloqueo cooperativo
La clase Context permite bloquear o ceder el contexto de ejecución actual.Bloquear o ceder es útil cuando el contexto actual no puede continuar porque un recurso no está disponible.
El concurrency::Context::Block método bloquea el contexto actual.Un contexto que se bloquea cede sus recursos de procesamiento para que el runtime pueda efectuar otras tareas.El concurrency::Context::Unblock método desbloquea un contexto bloqueado.Se debe llamar al método Context::Unblock desde un contexto diferente al que llamó a Context::Block.El tiempo de ejecución produce concurrency::context_self_unblock si se trata de un contexto desbloquearse a sí mismo.
Cooperativamente bloquear y desbloquear un contexto, se suele llamar a concurrency::Context::CurrentContext para recuperar un puntero a la Context objeto asociado con el subproceso actual y el resultado de almacenamiento.Después puede llamar al método Context::Block para bloquear el contexto actual.Después, llame a Context::Unblock desde un contexto independiente para desbloquear el contexto bloqueado.
Debe emparejar cada par de llamadas a Context::Block y Context::Unblock.El tiempo de ejecución produce concurrency::context_unblock_unbalanced cuando el Context::Block o Context::Unblock se llama al método consecutivamente sin una llamada similar a otro método.Sin embargo, no es necesario llamar a Context::Block antes de llamar a Context::Unblock.Por ejemplo, si un contexto llama a Context::Unblock antes de que otro contexto llame a Context::Block para el mismo contexto, ese contexto permanece desbloqueado.
El concurrency::Context::Yield método proporciona una ejecución para que el tiempo de ejecución puede realizar otras tareas y, a continuación, volver a programar el contexto de ejecución.Cuando se llama al método Context::Block, el runtime no reprograma el contexto.
Ejemplo
Para obtener un ejemplo en el que se usan los métodos Context::Block, Context::Unblock y Context::Yield para implementar una clase semáforo cooperativa, vea Cómo: Usar la clase Context para implementar un semáforo cooperativo.
Suscripción excesiva
El programador predeterminado crea el mismo número de subprocesos que los subprocesos de hardware disponibles.Puede utilizar la suscripción excesiva para crear subprocesos adicionales para un subproceso de hardware determinado.
Para operaciones intensivas, la suscripción excesiva normalmente no escala porque introduce sobrecarga adicional.Sin embargo, para las tareas que tienen una cantidad alta de latencia, por ejemplo, la lectura de datos desde el disco o desde una conexión de red, la suscripción excesiva puede mejorar la eficacia total de algunas aplicaciones.
[!NOTA]
Habilitar el exceso de suscripción sólo desde un subproceso que se creó con el tiempo de ejecución de simultaneidad.La suscripción excesiva no tiene ningún efecto cuando la llamada se produce desde un subproceso que no creó el runtime (aunque se trate del subproceso principal).
Para habilitar el exceso de suscripción en el contexto actual, llame a la concurrency::Context::Oversubscribe método con el _BeginOversubscription parámetro establecido en true.Cuando se habilita la suscripción excesiva en un subproceso creado por el Runtime de simultaneidad, hace que el runtime cree un subproceso adicional.Después de que finalicen todas las tareas que requieren suscripción excesiva, llame a Context::Oversubscribe con el parámetro _BeginOversubscription establecido en false.
Puede habilitar varias veces la suscripción excesiva para el contexto actual, pero debe deshabilitarla el mismo número de veces que la habilita.La suscripción excesiva también puede estar anidada, es decir, una tarea creada por otra tarea que usa suscripción excesiva también puede suscribir en exceso su contexto.Sin embargo, si una tarea anidada y su elemento primario pertenecen al mismo contexto, solo la llamada más externa a Context::Oversubscribe causa la creación de un subproceso adicional.
[!NOTA]
El tiempo de ejecución produce concurrency::invalid_oversubscribe_operation si se deshabilita el exceso de suscripción antes de que está activada.
Ejemplo
Para obtener un ejemplo que utiliza la suscripción en exceso para compensar la latencia que se produce leyendo los datos de una conexión de red, vea Cómo: Usar la suscripción excesiva para compensar la latencia.
Vea también
Tareas
Cómo: Usar grupos de programación para influir en el orden de ejecución
Cómo: Usar la clase Context para implementar un semáforo cooperativo
Cómo: Usar la suscripción excesiva para compensar la latencia