Návod: Přizpůsobení stávajícího kódu pro použití prostých úloh

Toto téma ukazuje, jak přizpůsobit existující kód, který používá rozhraní API systému Windows k vytváření a spouštění podprocesů použít lehký úkol.

A lehký úkol je úkol, který můžete naplánovat přímo concurrency::Scheduler nebo concurrency::ScheduleGroup objektu.Lehké úkoly jsou užitečné, pokud upravit existující kód pro použití funkce plánování modulu runtime souběžnosti.

Požadavky

Před zahájením tohoto návodu, přečtěte si téma Plánovač úloh (Concurrency Runtime).

Příklad

Description

Následující příklad ukazuje typické použití rozhraní API systému Windows k vytvoření a spuštění podprocesu.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.

Následující kroky ukazují, jak upravit kód příkladu pro použití modulu Runtime souběžnosti provést stejný úkol.

Úprava příkladu tak, aby používal prostou úlohu

1. Přidat #include pro concrt.h soubor záhlaví.

   #include <concrt.h>
   

2. Přidat using pro concurrency obor názvů.

   using namespace concurrency;
   

3. Změnit prohlášení o MyThreadFunction pro použití __cdecl konvence volání a vraťte se void.

   void __cdecl MyThreadFunction(LPVOID param);
   

4. Změnit MyData strukturu concurrency::event objekt, který signalizuje hlavní aplikaci, že úloha byla dokončena.

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

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

   CurrentScheduler::ScheduleTask(MyThreadFunction, pData);
   

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

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

7. Odebrat volání CloseHandle.

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

   void __cdecl MyThreadFunction(LPVOID lpParam)
   

9. Na konci MyThreadFunction fungovat, zavolejte concurrency::event::set metoda signál hlavní aplikaci, že úloha byla dokončena.

   pData->signal.set();
   

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

Příklad

Description

Vyplněný příklad ukazuje kód, který používá lehký úkol pro 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 (Concurrency Runtime)