Usando temporizadores de espera com uma chamada de procedimento assíncrono

  • Artigo

O exemplo a seguir associa uma função APC ( chamada de procedimento assíncrono ), também conhecida como rotina de conclusão, a um temporizador de espera quando o temporizador é definido. O endereço da rotina de conclusão é o quarto parâmetro para a função SetWaitableTimer . O quinto parâmetro é um ponteiro nulo que você pode usar para passar argumentos para a rotina de conclusão.

A rotina de conclusão será executada pelo mesmo thread chamado SetWaitableTimer. Esse thread deve estar em um estado alertável para executar a rotina de conclusão. Ele faz isso chamando a função SleepEx , que é uma função alertável.

Cada thread tem uma fila de APC. Se houver uma entrada na fila APC do thread no momento em que uma das funções alertáveis for chamada, o thread não será colocado em suspensão. Em vez disso, a entrada é removida da fila do APC e a rotina de conclusão é chamada.

Se nenhuma entrada existir na fila do APC, o thread será suspenso até que a espera seja atendida. A espera pode ser atendida adicionando uma entrada à fila do APC, por um tempo limite ou por um identificador que está sendo sinalizado. Se a espera for atendida por uma entrada na fila do APC, o thread será despertado e a rotina de conclusão será chamada. Nesse caso, o valor retornado da função é WAIT_IO_COMPLETION.

Depois que a rotina de conclusão é executada, o sistema verifica se há outra entrada na fila do APC a ser processada. Uma função alertável retornará somente depois que todas as entradas APC tiverem sido processadas. Portanto, se as entradas estiverem sendo adicionadas à fila do APC mais rapidamente do que podem ser processadas, é possível que uma chamada para uma função alertável nunca retorne. Isso é especialmente possível com temporizadores de espera, se o período for menor do que o tempo necessário para executar a rotina de conclusão.

Quando você estiver usando um temporizador de espera com um APC, o thread que define o temporizador não deve esperar no identificador do temporizador. Ao fazer isso, você faria com que o thread acordasse como resultado da sinalização do temporizador em vez de como resultado de uma entrada ser adicionada à fila do APC. Como resultado, o thread não está mais em um estado alertável e a rotina de conclusão não é chamada. No código a seguir, a chamada para SleepEx desperta o thread quando uma entrada é adicionada à fila APC do thread depois que o temporizador é definido como o estado sinalizado.

#define UNICODE 1
#define _UNICODE 1

#include <windows.h>
#include <stdio.h>
#include <tchar.h>

#define _SECOND 10000000

typedef struct _MYDATA {
   LPCTSTR szText;
   DWORD dwValue;
} MYDATA;

VOID CALLBACK TimerAPCProc(
   LPVOID lpArg,               // Data value
   DWORD dwTimerLowValue,      // Timer low value
   DWORD dwTimerHighValue )    // Timer high value

{
   // Formal parameters not used in this example.
   UNREFERENCED_PARAMETER(dwTimerLowValue);
   UNREFERENCED_PARAMETER(dwTimerHighValue);

   MYDATA *pMyData = (MYDATA *)lpArg;

   _tprintf( TEXT("Message: %s\nValue: %d\n\n"), pMyData->szText,
          pMyData->dwValue );
   MessageBeep(0);

}

int main( void ) 
{
   HANDLE          hTimer;
   BOOL            bSuccess;
   __int64         qwDueTime;
   LARGE_INTEGER   liDueTime;
   MYDATA          MyData;

   MyData.szText = TEXT("This is my data");
   MyData.dwValue = 100;

   hTimer = CreateWaitableTimer(
           NULL,                   // Default security attributes
           FALSE,                  // Create auto-reset timer
           TEXT("MyTimer"));       // Name of waitable timer
   if (hTimer != NULL)
   {
      __try 
      {
         // Create an integer that will be used to signal the timer 
         // 5 seconds from now.
         qwDueTime = -5 * _SECOND;

         // Copy the relative time into a LARGE_INTEGER.
         liDueTime.LowPart  = (DWORD) ( qwDueTime & 0xFFFFFFFF );
         liDueTime.HighPart = (LONG)  ( qwDueTime >> 32 );

         bSuccess = SetWaitableTimer(
            hTimer,           // Handle to the timer object
            &liDueTime,       // When timer will become signaled
            2000,             // Periodic timer interval of 2 seconds
            TimerAPCProc,     // Completion routine
            &MyData,          // Argument to the completion routine
            FALSE );          // Do not restore a suspended system

         if ( bSuccess ) 
         {
            for ( ; MyData.dwValue < 1000; MyData.dwValue += 100 ) 
            {
               SleepEx(
                  INFINITE,     // Wait forever
                  TRUE );       // Put thread in an alertable state
            }

         } 
         else 
         {
            printf("SetWaitableTimer failed with error %d\n", GetLastError());
         }

      } 
      __finally 
      {
         CloseHandle( hTimer );
      }
   } 
   else 
   {
      printf("CreateWaitableTimer failed with error %d\n", GetLastError());
   }

   return 0;
}

Usando objetos de temporizador de espera