Instrukcje: tworzenie zadania, które zostanie ukończone po opóźnieniu
W tym przykładzie pokazano, jak za pomocą concurrency::taskklas , concurrency::cancellation_token_source, concurrency::cancellation_token, concurrency::task_completion_event, concurrency::timeri concurrency::call utworzyć zadanie, które zostanie ukończone po opóźnieniu. Za pomocą tej metody można tworzyć pętle, które od czasu do czasu sondują dane. Możesz również wprowadzić limity czasu, opóźnić obsługę danych wejściowych użytkownika dla wstępnie określonego czasu itd.
Przykład: funkcje complete_after i cancel_after_timeout
W poniższym przykładzie przedstawiono complete_after funkcje i cancel_after_timeout . Funkcja complete_after tworzy task obiekt, który kończy się po określonym opóźnieniu. Używa timer obiektu i call obiektu do ustawiania task_completion_event obiektu po określonym opóźnieniu. Korzystając z task_completion_event klasy, można zdefiniować zadanie, które kończy się po wątku lub innym zadaniu sygnały, że wartość jest dostępna. Po ustawieniu zdarzenia zadania odbiornika zostaną ukończone, a ich kontynuacje będą uruchamiane.
Napiwek
Aby uzyskać więcej informacji na temat timer klas i call , które są częścią biblioteki agentów asynchronicznych, zobacz Asynchroniczne bloki komunikatów.
Funkcja cancel_after_timeout opiera się na complete_after funkcji, aby anulować zadanie, jeśli to zadanie nie zostanie ukończone przed danym limitem czasu. Funkcja cancel_after_timeout tworzy dwa zadania. Pierwsze zadanie wskazuje powodzenie i kończy się po zakończeniu podanego zadania. Drugie zadanie wskazuje błąd i kończy się po upływie określonego limitu czasu. Funkcja cancel_after_timeout tworzy zadanie kontynuacji, które jest uruchamiane po zakończeniu zadania zakończonego powodzeniem lub niepowodzeniem. Jeśli zadanie niepowodzenia zostanie ukończone jako pierwsze, kontynuacja anuluje źródło tokenu, aby anulować ogólne zadanie.
// Creates a task that completes after the specified delay.
task<void> complete_after(unsigned int timeout)
{
// A task completion event that is set when a timer fires.
task_completion_event<void> tce;
// Create a non-repeating timer.
auto fire_once = new timer<int>(timeout, 0, nullptr, false);
// Create a call object that sets the completion event after the timer fires.
auto callback = new call<int>([tce](int)
{
tce.set();
});
// Connect the timer to the callback and start the timer.
fire_once->link_target(callback);
fire_once->start();
// Create a task that completes after the completion event is set.
task<void> event_set(tce);
// Create a continuation task that cleans up resources and
// and return that continuation task.
return event_set.then([callback, fire_once]()
{
delete callback;
delete fire_once;
});
}
// Cancels the provided task after the specifed delay, if the task
// did not complete.
template<typename T>
task<T> cancel_after_timeout(task<T> t, cancellation_token_source cts, unsigned int timeout)
{
// Create a task that returns true after the specified task completes.
task<bool> success_task = t.then([](T)
{
return true;
});
// Create a task that returns false after the specified timeout.
task<bool> failure_task = complete_after(timeout).then([]
{
return false;
});
// Create a continuation task that cancels the overall task
// if the timeout task finishes first.
return (failure_task || success_task).then([t, cts](bool success)
{
if(!success)
{
// Set the cancellation token. The task that is passed as the
// t parameter should respond to the cancellation and stop
// as soon as it can.
cts.cancel();
}
// Return the original task.
return t;
});
}
Przykład: liczba obliczeń liczb pierwszych
Poniższy przykład oblicza liczbę liczb pierwszych w zakresie [0, 100000] wiele razy. Operacja kończy się niepowodzeniem, jeśli nie zostanie ukończona w danym limicie czasu. Funkcja count_primes pokazuje, jak używać cancel_after_timeout funkcji. Zlicza liczbę pierwszych w danym zakresie i kończy się niepowodzeniem, jeśli zadanie nie zostanie ukończone w podanym czasie. Funkcja wmain wywołuje count_primes funkcję wiele razy. Za każdym razem połówek limitu czasu. Program kończy się po zakończeniu operacji w bieżącym limicie czasu.
// Determines whether the input value is prime.
bool is_prime(int n)
{
if (n < 2)
return false;
for (int i = 2; i < n; ++i)
{
if ((n % i) == 0)
return false;
}
return true;
}
// Counts the number of primes in the range [0, max_value].
// The operation fails if it exceeds the specified timeout.
bool count_primes(unsigned int max_value, unsigned int timeout)
{
cancellation_token_source cts;
// Create a task that computes the count of prime numbers.
// The task is canceled after the specified timeout.
auto t = cancel_after_timeout(task<size_t>([max_value, timeout, cts]
{
combinable<size_t> counts;
parallel_for<unsigned int>(0, max_value + 1, [&counts, cts](unsigned int n)
{
// Respond if the overall task is cancelled by canceling
// the current task.
if (cts.get_token().is_canceled())
{
cancel_current_task();
}
// NOTE: You can replace the calls to is_canceled
// and cancel_current_task with a call to interruption_point.
// interruption_point();
// Increment the local counter if the value is prime.
if (is_prime(n))
{
counts.local()++;
}
});
// Return the sum of counts across all threads.
return counts.combine(plus<size_t>());
}, cts.get_token()), cts, timeout);
// Print the result.
try
{
auto primes = t.get();
wcout << L"Found " << primes << L" prime numbers within "
<< timeout << L" ms." << endl;
return true;
}
catch (const task_canceled&)
{
wcout << L"The task timed out." << endl;
return false;
}
}
int wmain()
{
// Compute the count of prime numbers in the range [0, 100000]
// until the operation fails.
// Each time the test succeeds, the time limit is halved.
unsigned int max = 100000;
unsigned int timeout = 5000;
bool success = true;
do
{
success = count_primes(max, timeout);
timeout /= 2;
} while (success);
}
/* Sample output:
Found 9592 prime numbers within 5000 ms.
Found 9592 prime numbers within 2500 ms.
Found 9592 prime numbers within 1250 ms.
Found 9592 prime numbers within 625 ms.
The task timed out.
*/
Jeśli używasz tej techniki do anulowania zadań po opóźnieniu, żadne nieuruchomione zadania nie będą uruchamiane po anulowaniu ogólnego zadania. Ważne jest jednak, aby wszystkie długotrwałe zadania szybko reagowały na anulowanie. Aby uzyskać więcej informacji na temat anulowania zadania, zobacz Anulowanie w PPL.
Kompletny przykład kodu
Oto kompletny kod dla tego przykładu:
// task-delay.cpp
// compile with: /EHsc
#include <ppl.h>
#include <ppltasks.h>
#include <agents.h>
#include <iostream>
using namespace concurrency;
using namespace std;
// Creates a task that completes after the specified delay.
task<void> complete_after(unsigned int timeout)
{
// A task completion event that is set when a timer fires.
task_completion_event<void> tce;
// Create a non-repeating timer.
auto fire_once = new timer<int>(timeout, 0, nullptr, false);
// Create a call object that sets the completion event after the timer fires.
auto callback = new call<int>([tce](int)
{
tce.set();
});
// Connect the timer to the callback and start the timer.
fire_once->link_target(callback);
fire_once->start();
// Create a task that completes after the completion event is set.
task<void> event_set(tce);
// Create a continuation task that cleans up resources and
// and return that continuation task.
return event_set.then([callback, fire_once]()
{
delete callback;
delete fire_once;
});
}
// Cancels the provided task after the specifed delay, if the task
// did not complete.
template<typename T>
task<T> cancel_after_timeout(task<T> t, cancellation_token_source cts, unsigned int timeout)
{
// Create a task that returns true after the specified task completes.
task<bool> success_task = t.then([](T)
{
return true;
});
// Create a task that returns false after the specified timeout.
task<bool> failure_task = complete_after(timeout).then([]
{
return false;
});
// Create a continuation task that cancels the overall task
// if the timeout task finishes first.
return (failure_task || success_task).then([t, cts](bool success)
{
if(!success)
{
// Set the cancellation token. The task that is passed as the
// t parameter should respond to the cancellation and stop
// as soon as it can.
cts.cancel();
}
// Return the original task.
return t;
});
}
// Determines whether the input value is prime.
bool is_prime(int n)
{
if (n < 2)
return false;
for (int i = 2; i < n; ++i)
{
if ((n % i) == 0)
return false;
}
return true;
}
// Counts the number of primes in the range [0, max_value].
// The operation fails if it exceeds the specified timeout.
bool count_primes(unsigned int max_value, unsigned int timeout)
{
cancellation_token_source cts;
// Create a task that computes the count of prime numbers.
// The task is canceled after the specified timeout.
auto t = cancel_after_timeout(task<size_t>([max_value, timeout, cts]
{
combinable<size_t> counts;
parallel_for<unsigned int>(0, max_value + 1, [&counts, cts](unsigned int n)
{
// Respond if the overall task is cancelled by canceling
// the current task.
if (cts.get_token().is_canceled())
{
cancel_current_task();
}
// NOTE: You can replace the calls to is_canceled
// and cancel_current_task with a call to interruption_point.
// interruption_point();
// Increment the local counter if the value is prime.
if (is_prime(n))
{
counts.local()++;
}
});
// Return the sum of counts across all threads.
return counts.combine(plus<size_t>());
}, cts.get_token()), cts, timeout);
// Print the result.
try
{
auto primes = t.get();
wcout << L"Found " << primes << L" prime numbers within "
<< timeout << L" ms." << endl;
return true;
}
catch (const task_canceled&)
{
wcout << L"The task timed out." << endl;
return false;
}
}
int wmain()
{
// Compute the count of prime numbers in the range [0, 100000]
// until the operation fails.
// Each time the test succeeds, the time limit is halved.
unsigned int max = 100000;
unsigned int timeout = 5000;
bool success = true;
do
{
success = count_primes(max, timeout);
timeout /= 2;
} while (success);
}
/* Sample output:
Found 9592 prime numbers within 5000 ms.
Found 9592 prime numbers within 2500 ms.
Found 9592 prime numbers within 1250 ms.
Found 9592 prime numbers within 625 ms.
The task timed out.
*/
Kompilowanie kodu
Aby skompilować kod, skopiuj go, a następnie wklej go w projekcie programu Visual Studio lub wklej go w pliku o nazwie task-delay.cpp , a następnie uruchom następujące polecenie w oknie wiersza polecenia programu Visual Studio.
cl.exe /EHsc task-delay.cpp
Zobacz też
Równoległość zadań
task, klasa (środowisko uruchomieniowe współbieżności)
cancellation_token_source, klasa
cancellation_token, klasa
task_completion_event, klasa
timer, klasa
call, klasa
Bloki komunikatów asynchronicznych
Anulowanie w PPL
Opinia
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź: https://aka.ms/ContentUserFeedback.
Prześlij i wyświetl opinię dla