> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# XTaskQueueRegisterMonitor

> XTaskQueueRegisterMonitor

# XTaskQueueRegisterMonitor

Registra una devolución de llamada que se invocará cada vez que se envíe una devolución de llamada a esta cola.

## Sintaxis

```cpp theme={null}
HRESULT XTaskQueueRegisterMonitor(  
         XTaskQueueHandle queue,  
         void* callbackContext,  
         XTaskQueueMonitorCallback* callback,  
         XTaskQueueRegistrationToken* token  
)  
```

### Parámetros

*queue*   \_In\_\
Tipo: XTaskQueueHandle

La cola en la que se registrará la devolución de llamada de envío.

*callbackContext*   \_In\_opt\_\
Tipo: void\*

Un puntero de contexto opcional que se pasará a la devolución de llamada de envío.

*callback*   \_In\_\
Tipo: [XTaskQueueMonitorCallback\*](/reference/system/xtaskqueue/functions/xtaskqueuemonitorcallback)

Una devolución de llamada que se invocará cuando se envíe una nueva devolución de llamada a la cola.

*token*   \_Out\_\
Tipo: [XTaskQueueRegistrationToken\*](/reference/system/xtaskqueue/structs/xtaskqueueregistrationtoken)

Un token que se usa al llamar a [XTaskQueueUnregisterMonitor](/reference/system/xtaskqueue/functions/xtaskqueueunregistermonitor) para quitar la devolución de llamada.

### Valor devuelto

Tipo: HRESULT

Código de error o de éxito HRESULT.

## Comentarios

<Note>No es seguro llamar a esta función en un subproceso sensible al tiempo. Para obtener más información, consulte [Subprocesos sensibles al tiempo](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/console-dev/overviews/threads/time-sensitive-threads).</Note>

En el ejemplo siguiente se muestra cómo se puede usar una cola de tareas para señalar una variable de condición cuando tiene elementos que distribuir. Una aplicación podría usar esto para compartir los subprocesos que usa para la cola de tareas con otro trabajo de la aplicación.

<Note>**SubmitCallback** es una función auxiliar que se define en el ejemplo de código de la función [XTaskQueueSubmitCallback](/reference/system/xtaskqueue/functions/xtaskqueuesubmitcallback).</Note>

```cpp theme={null}
// We will use condition variables to signal when there is something for us 
// in the queue and a bool to signal when we want the whole thing to close.
// Keep all this in a struct for convenient access
struct QueueControl
{
    std::condition_variable workActivity;
    std::mutex workMutex;
    std::condition_variable completionActivity;
    std::mutex completionMutex;
    bool terminate = false;
} queueControl;

void CALLBACK TaskQueueNewItemSubmitted(void* context, XTaskQueueHandle, XTaskQueuePort port)
{
    // A new callback has been submitted. notify the correct condition variable
    QueueControl* queueControl = static_cast<QueueControl*>(context);
    switch (port)
    {
    case XTaskQueuePort::Work:
        queueControl->workActivity.notify_all();
        break;

    case XTaskQueuePort::Completion:
        queueControl->completionActivity.notify_all();
        break;
    }
}

void CreatingTaskQueueWithManualSignaling()
{
    // Create a manual task queue
    XTaskQueueHandle queue;
    HRESULT hr = XTaskQueueCreate(
        XTaskQueueDispatchMode::Manual, 
        XTaskQueueDispatchMode::Manual, 
        &queue);

    if (FAILED(hr))
    {
        printf("Creating queue failed: 0x%x\r\n", hr);
        return;
    }

    // Listen to callback submitted notifications to signal
    // our condition variable.
    XTaskQueueRegistrationToken token;
    hr = XTaskQueueRegisterMonitor(
        queue, &queueControl, 
        TaskQueueNewItemSubmitted, &token);

    std::thread workThread([&]()
    {
        std::unique_lock<std::mutex> lock(queueControl.workMutex);
        while (!queueControl.terminate)
        {
            queueControl.workActivity.wait(lock);
            XTaskQueueDispatch(queue, XTaskQueuePort::Work, 0);
        }
    });

    std::thread completionThread([&]()
    {
        std::unique_lock<std::mutex> lock(queueControl.completionMutex);
        while (!queueControl.terminate)
        {
            queueControl.completionActivity.wait(lock);
            XTaskQueueDispatch(queue, XTaskQueuePort::Completion, 0);
        }
    });

    SubmitCallbacks(queue);

    // Wait a while for the callbacks to run
    Sleep(1000);

    XTaskQueueTerminate(queue, true, nullptr, nullptr);

    queueControl.terminate = true;
    queueControl.workActivity.notify_all();
    queueControl.completionActivity.notify_all();

    workThread.join();
    completionThread.join();
}
```

## Requisitos

**Encabezado:** XTaskQueue.h

**Biblioteca:** xgameruntime.lib

**Plataformas compatibles:** Windows, consolas de la familia XBOX One y consolas XBOX Series

## Documentación conceptual

* [Información general de la biblioteca XTaskQueue](/build/core-features/common/async/async-libraries/async-library-xtaskqueue)
* [Subprocesos sensibles al tiempo](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/console-dev/overviews/threads/time-sensitive-threads)

## Consulte también

[Miembros de XTaskQueue](/reference/system/xtaskqueue/xtaskqueue_members)\
[Modelo de programación asincrónica](/build/core-features/common/async/async-programming-model)\
[Diseño de la cola de tareas asincrónicas](/build/core-features/common/async/async-task-queue-design)


## Related topics

- [XTaskQueueUnregisterMonitor](/es/reference/system/xtaskqueue/functions/xtaskqueueunregistermonitor.md)
- [XTaskQueueMonitorCallback](/es/reference/system/xtaskqueue/functions/xtaskqueuemonitorcallback.md)
- [Realizar llamadas asincrónicas en la API de C de XSAPI](/es/services/xbox-services/fundamentals/xbox-services-api/live-flatc-async-patterns.md)
- [Realización de llamadas asincrónicas](/es/services/playfab/sdks/c/async.md)
- [Realización de llamadas asincrónicas en el SDK unificado de PlayFab](/es/services/playfab/sdks/unified-sdk/async-model.md)