Wait Functions

9/8/2008

Windows Embedded CE suporta único - objeto e múltiplo - objeto aguardar funções que bloco ou desbloquear um segmento, com base no estado do objeto.

O único-função objeto é WaitForSingleObject.

O múltiplo-objeto funções são WaitForMultipleObjects e MsgWaitForMultipleObjects.

O WaitForSingleObject função define um segmento para aguardar um único objeto. O objeto pode ser um objeto sincronização, como um evento ou mutex ou o objeto pode ser um identificador para um processo e segmento.

Identificadores são sinalizado quando seus finalizar processos ou segmentos. Assim, um processo pode monitor outro processo ou segmento e executar alguma ação baseia o status do processo ou segmento.

O WaitForMultipleObjects e MsgWaitForMultipleObjects habilitar funções o segmento chamado para especificar uma matriz que contém um ou mais alças objeto sincronização. Essas funções retornam quando um do seguinte eventos ocorre:

• O estado de um objeto especificado é definido como sinalizado.
• O intervalo tempo limite decorrido.
  Você pode definir o intervalo tempo limite como INFINITE para especificar que o tempo limite não tempo limite.

Windows Embedded CE não suporte aguardando todos os objetos a ser sinalizado.

O seguinte exemplo de código mostra como usar CreateEvent para criar dois objetos evento. Em seguida, usa os objetos criados dois como parâmetros na chamar para WaitForMultipleObjects. WaitForMultipleObjects Não retorna até que um dos objetos seja sinalizado.

int EventsExample (void)
{
   HANDLE hEvents[2];
   DWORD dwEvent;
   int i;
   for (i = 0; i < 2; i++)
   {
      hEvents[i] = CreateEvent (NULL,   // No security attributes
                              FALSE,  // Auto-reset event object
                              FALSE,  // Initial state is nonsignaled
                              NULL);  // Unnamed object
      if (hEvents[i] == NULL)
      {
         // Your error handling code goes here.
         MessageBox (NULL, TEXT("CreateEvent error!"), TEXT("Error"), MB_OK);
         // You can use GetLastError to obtain more information.
         return 0;
      }
   }
   // Put code that uses the events here; that is, startup of threads, which will set the events when completed.
   dwEvent = WaitForMultipleObjects
   (
      2, // Number of objects in an array
      hEvents, // Array of objects
      FALSE, // Wait for any (required under Windows Embedded CE)
      INFINITE); // Indefinite wait
   switch (dwEvent)
   {
      case WAIT_OBJECT_0 + 0: // First event was signaled
      case WAIT_OBJECT_0 + 1: // Second event was signaled
      break;
      default:
      // Your error handling code goes here.
      MessageBox (NULL, TEXT("Wait error!"), TEXT("Error"), MB_OK);
      // You can use GetLastError to obtain more information.
      return 0;
   }
   return 1;
} // End of EventsExample code

MsgWaitForMultipleObjects é semelhante a WaitForMultipleObjects, exceto pelo fato de que ela permite que você especificar entrada objetos evento na matriz de manipulador de objeto. Selecione o tipo de entrada evento para aguardar in a dwWakeMask parâmetro.

MsgWaitForMultipleObjects Não retorna se há entrada não lida do tipo especificado na fila. Ele retorna somente quando chega Nova entrada.

Exemplo, um segmento pode usar MsgWaitForMultipleObjects Com sua dwWakeMask parâmetro definido como QS_KEY. Isso bloqueia-la até que o estado de um objeto especificado está sinalizado ou até que entrada do teclado está disponível na entrada do segmento de fila. O segmento pode usar a função GetMessage PeekMessage ou para obter a entrada.

O seguinte exemplo de código mostra como usar MsgWaitForMultipleObjects Em executar um loop uma mensagem. O executar um loop continua até que uma mensagem WM_QUIT Consta a fila. O dwWakeMask parâmetro está definido como QS_ALLINPUT para que todas as mensagens são verificadas.

int MessageLoop
   (
      HANDLE* lphObjects, // Handles that need to be waited on
      int     iObjCount ) // Number of handles to wait on
      {
         while (TRUE)
         {
            // Block-local variables
            DWORD dwResult;
            MSG msgCurrent;
            while (PeekMessage (&msgCurrent, NULL, 0, 0, PM_REMOVE))
            {
               if (WM_QUIT == msgCurrent.message)
               return 1;
               DispatchMessage (&msgCurrent);
            }
         dwResult = MsgWaitForMultipleObjects (iObjCount, lphObjects, FALSE, INFINITE, QS_ALLINPUT);
         if (dwResult == DWORD(WAIT_OBJECT_0 + iObjCount))
         {
            // Some input was received - go around loop again
            continue;
         }
      else 
      {
         // Check for errors and handle them here. If not an error,
         // write code which processes the result here.  Be sure to
         // create code that provides some way to get out of the loop!
         // The index for the signaled is 
         // (dwResult - WAIT_OBJECT_0).
      }
   }
}

Observação

Tenha cuidado ao usar funções de espera e codificar que direta ou indiretamente cria janelas.Se um segmento cria janelas, ele deverá mensagens processo.Difusões de mensagem são enviadas para todas as janelas no sistema.Se um segmento usa uma função de espera com nenhum intervalo tempo limite, bloqueios de sistema.Um exemplo de codificar que indiretamente cria uma janela é a Modelo de Objeto Componente (COM) CoInitialize função.Se você tiver um segmento que cria janelas, use MsgWaitForMultipleObjects, vez o outro aguardar funções.

See Also

Concepts

Synchronization