Návod: Přizpůsobení existující kód použít zjednodušené úkoly

Toto téma ukazuje, jak přizpůsobit existující kód, který používá rozhraní API systému Windows vytvořit a spustit podproces použití lehký úkol.

A lehký úkol úkol naplánovat přímo z je concurrency::Scheduler nebo concurrency::ScheduleGroup objektu.Lehký úkoly jsou užitečné pro přizpůsobení existující kód pomocí funkce plánování Runtime souběžnosti.

Požadavky

Před zahájením tohoto postupu, přečtěte si téma Plánovač úloh (souběžnosti Runtime).

Příklad

Description

Následující příklad ukazuje typické použití rozhraní API systému Windows vytvořit a spustit podproces.V tomto příkladu CreateThread funkce pro volání MyThreadFunction na samostatný podproces.

Kód

// windows-threads.cpp
#include <windows.h>
#include <tchar.h>
#include <strsafe.h>

#define BUF_SIZE 255

DWORD WINAPI MyThreadFunction(LPVOID param);

// Data structure for threads to use.
typedef struct MyData {
    int val1;
    int val2;
} MYDATA, *PMYDATA;

int _tmain()
{
   // Allocate memory for thread data.
   PMYDATA pData = (PMYDATA) HeapAlloc(GetProcessHeap(), 
      HEAP_ZERO_MEMORY, sizeof(MYDATA));

   if( pData == NULL )
   {
      ExitProcess(2);
   }

   // Set the values of the thread data.
   pData->val1 = 50;
   pData->val2 = 100;

   // Create the thread to begin execution on its own.
   DWORD dwThreadId;
   HANDLE hThread = CreateThread( 
      NULL,                   // default security attributes
      0,                      // use default stack size  
      MyThreadFunction,       // thread function name
      pData,                  // argument to thread function 
      0,                      // use default creation flags 
      &dwThreadId);           // returns the thread identifier 

   if (hThread == NULL) 
   {      
      ExitProcess(3);
   }

   // Wait for the thread to finish.
   WaitForSingleObject(hThread, INFINITE);

   // Close the thread handle and free memory allocation.
   CloseHandle(hThread);
   HeapFree(GetProcessHeap(), 0, pData);

   return 0;
}

DWORD WINAPI MyThreadFunction(LPVOID lpParam)
{
   PMYDATA pData = (PMYDATA)lpParam;

   // Use thread-safe functions to print the parameter values.

   TCHAR msgBuf[BUF_SIZE];
   StringCchPrintf(msgBuf, BUF_SIZE, TEXT("Parameters = %d, %d\n"), 
     pData->val1, pData->val2); 

   size_t cchStringSize;
   StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);

   DWORD dwChars;
   WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), msgBuf, (DWORD)cchStringSize, &dwChars, NULL);

   return 0;
}

Komentáře

Tento příklad vytvoří následující výstup.

Parameters = 50, 100

Následující pokyny popisují postup Přizpůsobit ukázkový kód použití Runtime souběžnosti provést stejný úkol.

Příklad použití lehký úkol přizpůsobit

1. Přidat #include směrnice pro concrt.h hlavičky souboru.

   #include <concrt.h>
   

2. Přidat using směrnice pro concurrency oboru názvů.

   using namespace concurrency;
   

3. Změna prohlášení o MyThreadFunction pro použití __cdecl konvence volání a vrátit void.

   void __cdecl MyThreadFunction(LPVOID param);
   

4. Změnit MyData struktury zahrnout concurrency::event objekt, který signalizuje hlavních aplikací, dokončení úkolu.

   typedef struct MyData {
       int val1;
       int val2;
       event signal;
   } MYDATA, *PMYDATA;
   

5. Nahradit volání CreateThread s voláním concurrency::CurrentScheduler::ScheduleTask metoda.

   CurrentScheduler::ScheduleTask(MyThreadFunction, pData);
   

6. Nahradit volání WaitForSingleObject s voláním concurrency::event::wait metoda čekat na dokončení úlohy.

   // Wait for the task to finish.
   pData->signal.wait();
   

7. Odebrat volání CloseHandle.

8. Změna podpisu definice MyThreadFunction podle kroku 3.

   void __cdecl MyThreadFunction(LPVOID lpParam)
   

9. Na konci MyThreadFunction fungovat, zavolejte concurrency::event::set metoda signál hlavních aplikací, dokončení úkolu.

   pData->signal.set();
   

10. Odebrat return prohlášení z MyThreadFunction.

Příklad

Description

Následující vyplněný příklad kódu, který používá lehký úkol volání MyThreadFunction funkce.

Kód

// migration-lwt.cpp
// compile with: /EHsc
#include <windows.h>
#include <tchar.h>
#include <strsafe.h>
#include <concrt.h>

using namespace concurrency;

#define BUF_SIZE 255

void __cdecl MyThreadFunction(LPVOID param);

// Data structure for threads to use.
typedef struct MyData {
    int val1;
    int val2;
    event signal;
} MYDATA, *PMYDATA;

int _tmain()
{
   // Allocate memory for thread data.
   PMYDATA pData = (PMYDATA) HeapAlloc(GetProcessHeap(), 
      HEAP_ZERO_MEMORY, sizeof(MYDATA));

   if( pData == NULL )
   {
      ExitProcess(2);
   }

   // Set the values of the thread data.
   pData->val1 = 50;
   pData->val2 = 100;

   // Create the thread to begin execution on its own.
   CurrentScheduler::ScheduleTask(MyThreadFunction, pData);

   // Wait for the task to finish.
   pData->signal.wait();

   // Free memory allocation.
   HeapFree(GetProcessHeap(), 0, pData);

   return 0;
}

void __cdecl MyThreadFunction(LPVOID lpParam)
{
   PMYDATA pData = (PMYDATA)lpParam;

   // Use thread-safe functions to print the parameter values.

   TCHAR msgBuf[BUF_SIZE];
   StringCchPrintf(msgBuf, BUF_SIZE, TEXT("Parameters = %d, %d\n"), 
     pData->val1, pData->val2); 

   size_t cchStringSize;
   StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);

   DWORD dwChars;
   WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), msgBuf, (DWORD)cchStringSize, &dwChars, NULL);

   pData->signal.set();
}

Viz také

Referenční dokumentace

Třída plánovače

Koncepty

Plánovač úloh (souběžnosti Runtime)