Jak: zadat specifické zásady Plánovač

Článek
05/01/2013

Plánovač zásady umožňuje určit strategii, která používá Plánovač při správě úkolů.Toto téma ukazuje, jak pomocí zásad Plánovač zvýšit prioritu podprocesu úkolu, který vytiskne ukazatel průběhu do konzoly.

Příklad používá vlastní Plánovač zásady spolu s asynchronní agenti, viz Jak: Vytvoření agentů, které používají určité zásady Plánovač.

Příklad

Následující příklad provádí souběžně dva úkoly.První úkol vypočítá nth Fibonacci číslo.Druhý úkol vytiskne ukazatel průběhu do konzoly.

První úkol používá rekurzivní rozložené vypočítat Fibonacci číslo.Každý úkol rekurzivně, vytvoří dílčích vypočítat celkový výsledek.Úkol, který používá rekurzivní rozložené mohou použít všechny dostupné prostředky a tím starve další úkoly.V tomto příkladu není úkol, který vytiskne ukazatel průběhu obdržet včasný přístup k výpočetní prostředky.

Chcete-li úkol, který vytiskne zprávu průběh spravedlivý přístup k výpočetních prostředků, v tomto příkladu kroky popsané v Jak: Správa Instance Plánovač vytvořte instanci Plánovač, který má vlastní zásady.Vlastní zásada určuje prioritu podprocesu je nejvyšší prioritou.

V tomto příkladu concurrency::call a concurrency::timer třídy ukazatel průběhu tisku.Tyto třídy mají verze jejich konstruktory, odkaz na, které concurrency::Scheduler objekt, který je naplánuje.V příkladu je Plánovač výchozí naplánování úkolu, vypočítá počet Fibonacci a Plánovač instance k naplánování úlohy, která tiskne indikátor průběhu.

Výhody použití plánovače, který má vlastní zásadu pro ilustraci tento příklad provádí celkové úkol dvakrát.V prvním příkladu Plánovač výchozí naplánování oba úkoly.Příklad pak používá výchozí Plánovač první úkol naplánovat a Plánovač, který má vlastní zásadu druhého úkolu.

// scheduler-policy.cpp
// compile with: /EHsc
#include <windows.h>
#include <ppl.h>
#include <agents.h>
#include <iostream>

using namespace concurrency;
using namespace std;

// Computes the nth Fibonacci number.
// This function illustrates a lengthy operation and is therefore
// not optimized for performance.
int fibonacci(int n)
{
   if (n < 2)
      return n;

   // Compute the components in parallel.
   int n1, n2;
   parallel_invoke(
      [n,&n1] { n1 = fibonacci(n-1); },
      [n,&n2] { n2 = fibonacci(n-2); }
   );

   return n1 + n2;
}

// Prints a progress indicator while computing the nth Fibonacci number.
void fibonacci_with_progress(Scheduler& progress_scheduler, int n)
{
   // Use a task group to compute the Fibonacci number.
   // The tasks in this group are scheduled by the current scheduler.
   structured_task_group tasks;

   auto task = make_task([n] {
      fibonacci(n);
   });
   tasks.run(task);

   // Create a call object that prints its input to the console.
   // This example uses the provided scheduler to schedule the 
   // task that the call object performs.
   call<wchar_t> c(progress_scheduler, [](wchar_t c) { 
      wcout << c; 
   });

   // Connect the call object to a timer object. The timer object
   // sends a progress message to the call object every 100 ms.
   // This example also uses the provided scheduler to schedule the 
   // task that the timer object performs.
   timer<wchar_t> t(progress_scheduler, 100, L'.', &c, true);
   t.start();

   // Wait for the task that computes the Fibonacci number to finish.
   tasks.wait();

   // Stop the timer.
   t.stop();

   wcout << L"done" << endl;
}

int wmain()
{  
   // Calculate the 38th Fibonacci number.
   const int n = 38;

   // Use the default scheduler to schedule the progress indicator while 
   // the Fibonacci number is calculated in the background.

   wcout << L"Default scheduler:" << endl;
   fibonacci_with_progress(*CurrentScheduler::Get(), n);

   // Now use a scheduler that has a custom policy for the progress indicator.
   // The custom policy specifies the thread priority to the highest 
   // priority class.

   SchedulerPolicy policy(1, ContextPriority, THREAD_PRIORITY_HIGHEST);
   Scheduler* scheduler = Scheduler::Create(policy);

   // Register to be notified when the scheduler shuts down.
   HANDLE hShutdownEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   scheduler->RegisterShutdownEvent(hShutdownEvent);

   wcout << L"Scheduler that has a custom policy:" << endl;
   fibonacci_with_progress(*scheduler, n);

   // Release the final reference to the scheduler. This causes the scheduler
   // to shut down.
    scheduler->Release();

   // Wait for the scheduler to shut down and destroy itself.
   WaitForSingleObject(hShutdownEvent, INFINITE);

   // Close the event handle.
   CloseHandle(hShutdownEvent);
}

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

Default scheduler:
...........................................................................done
Scheduler that has a custom policy:
...........................................................................done

Přestože obě sady úkolů vytvoří stejné výsledky, verzi, která používá vlastní zásady umožňuje úkol, který vytiskne ukazatel průběhu spuštění zvýšenými priority tak, aby se chová více responsively.

Probíhá kompilace kódu

Příklad kódu zkopírujte a vložte do projektu Visual Studio nebo vložit do souboru s názvem Plánovač policy.cpp a spusťte následující příkaz v okně příkazového řádku Visual Studio.

cl.exe /EHsc scheduler-policy.cpp

Viz také

Úkoly

Jak: Správa Instance Plánovač

Jak: Vytvoření agentů, které používají určité zásady Plánovač

Koncepty

Plánovač zásady

Sdílet prostřednictvím