Eşzamanlılık Çalışma Zamanında Özel Durum İşleme
Eşzamanlılık Çalışma Zamanı, birçok hata türünü iletmek için C++ özel durum işlemesini kullanır. Bu hatalar çalışma zamanının geçersiz kullanımını, kaynak alma hatası gibi çalışma zamanı hatalarını ve görevlere ve görev gruplarına sağladığınız iş işlevlerinde oluşan hataları içerir. Bir görev veya görev grubu özel durum oluştururken, çalışma zamanı bu özel durumu tutar ve görev veya görev grubunun bitmesini bekleyen bağlama göre sıralar. Basit görevler ve aracılar gibi bileşenler için çalışma zamanı sizin için özel durumları yönetmez. Böyle durumlarda, kendi özel durum işleme mekanizmanızı uygulamanız gerekir. Bu konu, çalışma zamanının görevler, görev grupları, basit görevler ve zaman uyumsuz aracılar tarafından oluşan özel durumları nasıl işlediğini ve uygulamalarınızdaki özel durumlara nasıl yanıt vereceğini açıklar.
Önemli Noktalar
Bir görev veya görev grubu özel durum oluştururken, çalışma zamanı bu özel durumu tutar ve görev veya görev grubunun bitmesini bekleyen bağlama göre sıralar.
Mümkün olduğunda, kurtarabileceğiniz hataları işlemek için her eşzamanlılık::task::get ve concurrency::task::wait çağrısını bir
try/catchblokla çevreleyin. Çalışma zamanı, bir görev özel durum oluşturursa ve bu özel durum görev, devamlılıklarından biri veya ana uygulama tarafından yakalanmazsa uygulamayı sonlandırır.Görev tabanlı devamlılık her zaman çalışır; öncül görevin başarıyla tamamlanıp tamamlanmadığı, özel durum oluşturup oluşturmadığı veya iptal edilmiş olması önemli değildir. Öncül görev oluşturur veya iptal ederse değer tabanlı devamlılık çalışmaz.
Görev tabanlı devamlılıklar her zaman çalıştığından, devamlılık zincirinizin sonuna görev tabanlı devamlılık eklenip eklenmeyeceğini göz önünde bulundurun. Bu, kodunuzun tüm özel durumları gözlemlediğini garantiye yardımcı olabilir.
Eşzamanlılık::görev::get çağrısı yaptığınızda çalışma zamanı eşzamanlılık::task_canceled oluşturur ve bu görev iptal edilir.
Çalışma zamanı, basit görevler ve aracılar için özel durumları yönetmez.
Bu Belgede
Görevler ve Devamlılıklar
Bu bölümde çalışma zamanının eşzamanlılık::görev nesneleri ve bunların devamlılıkları tarafından oluşturulan özel durumları nasıl işlediği açıklanmaktadır. Görev ve devamlılık modeli hakkında daha fazla bilgi için bkz . Görev Paralelliği.
Bir nesneye task geçirdiğiniz bir iş işlevinin gövdesine özel durum oluşturduğunuzda, çalışma zamanı bu özel durumu depolar ve bunu eşzamanlılık::task::get veya eşzamanlılık::task::wait çağıran bağlama sıralar. Görev Paralelliği belgesi, görev tabanlı ve değer tabanlı devamlılıkları açıklar, ancak özetlemek gerekirse, değer tabanlı devamlılık türünde T bir parametre alır ve görev tabanlı devamlılık türünde task<T>bir parametre alır. Oluşturan bir görevin bir veya daha fazla değer tabanlı devamlılığı varsa, bu devamlılıklar çalıştırılacak şekilde zamanlanmaz. Aşağıdaki örnekte bu davranış gösterilmektedir:
// eh-task.cpp
// compile with: /EHsc
#include <ppltasks.h>
#include <iostream>
using namespace concurrency;
using namespace std;
int wmain()
{
wcout << L"Running a task..." << endl;
// Create a task that throws.
auto t = create_task([]
{
throw exception();
});
// Create a continuation that prints its input value.
auto continuation = t.then([]
{
// We do not expect this task to run because
// the antecedent task threw.
wcout << L"In continuation task..." << endl;
});
// Wait for the continuation to finish and handle any
// error that occurs.
try
{
wcout << L"Waiting for tasks to finish..." << endl;
continuation.wait();
// Alternatively, call get() to produce the same result.
//continuation.get();
}
catch (const exception& e)
{
wcout << L"Caught exception." << endl;
}
}
/* Output:
Running a task...
Waiting for tasks to finish...
Caught exception.
*/
Görev tabanlı devamlılık, öncül görev tarafından oluşan özel durumları işlemenizi sağlar. Görev tabanlı devamlılık her zaman çalışır; görevin başarıyla tamamlanıp tamamlanmadığı, özel durum oluşturup oluşturmadığı veya iptal edilip edilmediği önemli değildir. Bir görev özel durum oluştururken, görev tabanlı devamlılıkları çalıştırılacak şekilde zamanlanır. Aşağıdaki örnekte her zaman oluşturan bir görev gösterilmektedir. Görevin iki devamı vardır; biri değer tabanlı, diğeri ise görev tabanlıdır. Görev tabanlı özel durum her zaman çalışır ve bu nedenle öncül görev tarafından oluşan özel durumu yakalayabilir. Örnek her iki devamlılıkların da tamamlanmasını beklediğinde, görev özel durumu her zaman çağrıldığında veya task::wait çağrıldığında task::get oluştuğundan özel durum yeniden oluşturulur.
// eh-continuations.cpp
// compile with: /EHsc
#include <ppltasks.h>
#include <iostream>
using namespace concurrency;
using namespace std;
int wmain()
{
wcout << L"Running a task..." << endl;
// Create a task that throws.
auto t = create_task([]() -> int
{
throw exception();
return 42;
});
//
// Attach two continuations to the task. The first continuation is
// value-based; the second is task-based.
// Value-based continuation.
auto c1 = t.then([](int n)
{
// We don't expect to get here because the antecedent
// task always throws.
wcout << L"Received " << n << L'.' << endl;
});
// Task-based continuation.
auto c2 = t.then([](task<int> previousTask)
{
// We do expect to get here because task-based continuations
// are scheduled even when the antecedent task throws.
try
{
wcout << L"Received " << previousTask.get() << L'.' << endl;
}
catch (const exception& e)
{
wcout << L"Caught exception from previous task." << endl;
}
});
// Wait for the continuations to finish.
try
{
wcout << L"Waiting for tasks to finish..." << endl;
(c1 && c2).wait();
}
catch (const exception& e)
{
wcout << L"Caught exception while waiting for all tasks to finish." << endl;
}
}
/* Output:
Running a task...
Waiting for tasks to finish...
Caught exception from previous task.
Caught exception while waiting for all tasks to finish.
*/
İşleyebileceğin özel durumları yakalamak için görev tabanlı devamlılıkları kullanmanızı öneririz. Görev tabanlı devamlılıklar her zaman çalıştığından, devamlılık zincirinizin sonuna görev tabanlı devamlılık eklenip eklenmeyeceğini göz önünde bulundurun. Bu, kodunuzun tüm özel durumları gözlemlediğini garantiye yardımcı olabilir. Aşağıdaki örnekte temel bir değer tabanlı devamlılık zinciri gösterilmektedir. Zincirdeki üçüncü görev oluşturur ve bu nedenle onu izleyen değer tabanlı devamlılıklar çalıştırılmaz. Ancak, son devamlılık görev tabanlıdır ve bu nedenle her zaman çalışır. Bu son devamlılık, üçüncü görev tarafından oluşan özel durumu işler.
Kullanabileceğiniz en özel özel durumları yakalamanızı öneririz. Yakalamak için belirli özel durumlarınız yoksa bu son görev tabanlı devamlılığı atlayabilirsiniz. Herhangi bir özel durum işlenmemiş olarak kalır ve uygulamayı sonlandırabilir.
// eh-task-chain.cpp
// compile with: /EHsc
#include <ppltasks.h>
#include <iostream>
using namespace concurrency;
using namespace std;
int wmain()
{
int n = 1;
create_task([n]
{
wcout << L"In first task. n = ";
wcout << n << endl;
return n * 2;
}).then([](int n)
{
wcout << L"In second task. n = ";
wcout << n << endl;
return n * 2;
}).then([](int n)
{
wcout << L"In third task. n = ";
wcout << n << endl;
// This task throws.
throw exception();
// Not reached.
return n * 2;
}).then([](int n)
{
// This continuation is not run because the previous task throws.
wcout << L"In fourth task. n = ";
wcout << n << endl;
return n * 2;
}).then([](task<int> previousTask)
{
// This continuation is run because it is task-based.
try
{
// The call to task::get rethrows the exception.
wcout << L"In final task. result = ";
wcout << previousTask.get() << endl;
}
catch (const exception&)
{
wcout << L"<exception>" << endl;
}
}).wait();
}
/* Output:
In first task. n = 1
In second task. n = 2
In third task. n = 4
In final task. result = <exception>
*/
Bahşiş
Bir özel durumu bir görev tamamlama olayıyla ilişkilendirmek için eşzamanlılık::task_completion_event::set_exception yöntemini kullanabilirsiniz. Görev Paralelliği belgesi eşzamanlılık::task_completion_event sınıfını daha ayrıntılı olarak açıklar.
concurrency::task_canceled , ile ilişkili taskönemli bir çalışma zamanı özel durum türüdür. Çağırdığınızda task::get çalışma zamanı oluşturulur task_canceled ve bu görev iptal edilir. (Buna karşılık, task::wait task_status::canceled döndürür ve atılmaz.) Bu özel durumu, görev tabanlı bir devamlılık veya çağırdığınızda task::getyakalayabilir ve işleyebilirsiniz. Görev iptali hakkında daha fazla bilgi için bkz . PPL'de İptal.
Dikkat
Kodunuzdan asla atmayın task_canceled . Bunun yerine eşzamanlılık::cancel_current_task çağrısı yapın.
Çalışma zamanı, bir görev özel durum oluşturursa ve bu özel durum görev, devamlılıklarından biri veya ana uygulama tarafından yakalanmazsa uygulamayı sonlandırır. Uygulamanız kilitleniyorsa, C++ özel durumları oluştuğunda Visual Studio'yu kıracak şekilde yapılandırabilirsiniz. İşlenmeyen özel durumun konumunu tanıladıktan sonra, bunu işlemek için görev tabanlı bir devamlılık kullanın.
Bu belgede Çalışma Zamanı Tarafından Atılan Özel Durumlar bölümü, çalışma zamanı özel durumlarıyla nasıl çalışıldığını daha ayrıntılı olarak açıklar.
[Üst]
Görev Grupları ve Paralel Algoritmalar
Bu bölümde, çalışma zamanının görev grupları tarafından oluşan özel durumları nasıl işlediği açıklanmaktadır. Bu bölüm eşzamanlılık::p arallel_for gibi paralel algoritmalar için de geçerlidir çünkü bu algoritmalar görev grupları üzerinde oluşturulur.
Dikkat
Özel durumların bağımlı görevler üzerindeki etkilerini anladığınızdan emin olun. Özel durum işlemeyi görevler veya paralel algoritmalarla kullanma hakkında önerilen yöntemler için Paralel Desen kitaplığındaki en iyi yöntemler konusundaki İptal ve Özel Durum İşlemenin Nesne Yok Etme özelliğini nasıl etkilediğini anlama bölümüne bakın.
Görev grupları hakkında daha fazla bilgi için bkz . Görev Paralelliği. Paralel algoritmalar hakkında daha fazla bilgi için bkz . Paralel Algoritmalar.
Eşzamanlılık::task_group veya eşzamanlılık::structured_task_group nesnesine geçirdiğiniz bir iş işlevinin gövdesine özel durum oluşturduğunuzda, çalışma zamanı bu özel durumu depolar ve eşzamanlılığı çağıran bağlama göre sıralar::task_group::wait, eşzamanlılık::structured_task_group::bekleme, eşzamanlılık::task_group::run_and_wait veya eşzamanlılık:: structured_task_group::run_and_wait. Çalışma zamanı ayrıca görev grubundaki tüm etkin görevleri (alt görev gruplarındakiler dahil) durdurur ve henüz başlatılmamış görevleri atar.
Aşağıdaki örnekte, özel durum oluşturan bir iş işlevinin temel yapısı gösterilmektedir. Örnek, iki point nesnenin değerlerini paralel olarak yazdırmak için bir task_group nesne kullanır. print_point work işlevi, bir point nesnenin değerlerini konsola yazdırır. İş işlevi, giriş değeri ise NULLbir özel durum oluşturur. Çalışma zamanı bu özel durumu depolar ve çağıran task_group::waitbağlama göre sıralar.
// eh-task-group.cpp
// compile with: /EHsc
#include <ppl.h>
#include <iostream>
#include <sstream>
using namespace concurrency;
using namespace std;
// Defines a basic point with X and Y coordinates.
struct point
{
int X;
int Y;
};
// Prints the provided point object to the console.
void print_point(point* pt)
{
// Throw an exception if the value is NULL.
if (pt == NULL)
{
throw exception("point is NULL.");
}
// Otherwise, print the values of the point.
wstringstream ss;
ss << L"X = " << pt->X << L", Y = " << pt->Y << endl;
wcout << ss.str();
}
int wmain()
{
// Create a few point objects.
point pt = {15, 30};
point* pt1 = &pt;
point* pt2 = NULL;
// Use a task group to print the values of the points.
task_group tasks;
tasks.run([&] {
print_point(pt1);
});
tasks.run([&] {
print_point(pt2);
});
// Wait for the tasks to finish. If any task throws an exception,
// the runtime marshals it to the call to wait.
try
{
tasks.wait();
}
catch (const exception& e)
{
wcerr << L"Caught exception: " << e.what() << endl;
}
}
Bu örnek aşağıdaki çıkışı oluşturur.
X = 15, Y = 30Caught exception: point is NULL.
Bir görev grubunda özel durum işleme kullanan eksiksiz bir örnek için bkz . Nasıl yapılır: Paralel Döngüden Ayrılmak için Özel Durum İşlemeyi Kullanma.
[Üst]
Çalışma Zamanı Tarafından Oluşan Özel Durumlar
Özel durum, çalışma zamanı çağrısından kaynaklanabilir. Eşzamanlılık::task_canceled ve eşzamanlılık::operation_timed_out dışında çoğu özel durum türü programlama hatasını gösterir. Bu hatalar genellikle kurtarılamaz ve bu nedenle uygulama kodu tarafından yakalanmamalı veya işlenmemelidir. Yalnızca programlama hatalarını tanılamanız gerektiğinde uygulama kodunuzda kurtarılamayan hataları yakalamanızı veya işlemenizi öneririz. Ancak, çalışma zamanı tarafından tanımlanan özel durum türlerini anlamak programlama hatalarını tanılamanıza yardımcı olabilir.
Özel durum işleme mekanizması, çalışma zamanı tarafından iş işlevleri tarafından oluşan özel durumlar olarak oluşan özel durumlar için aynıdır. Örneğin, concurrency::receive işlevi belirtilen zaman aralığında bir ileti almadığında oluşturur operation_timed_out . Bir görev grubuna geçirdiğiniz bir iş işlevinde özel durum oluşturursareceive, çalışma zamanı bu özel durumu depolar ve bunu , , structured_task_group::waittask_group::run_and_waitveya structured_task_group::run_and_waitçağıran task_group::waitbağlama göre sıralar.
Aşağıdaki örnek, iki görevi paralel olarak çalıştırmak için eşzamanlılık::p arallel_invoke algoritmasını kullanır. İlk görev beş saniye bekler ve sonra bir ileti arabelleğine bir ileti gönderir. İkinci görev, aynı ileti arabelleğinden bir ileti almak için üç saniye beklemek için işlevini kullanır receive . İşlev, receive iletiyi zaman aralığında almazsa oluşturur operation_timed_out .
// eh-time-out.cpp
// compile with: /EHsc
#include <agents.h>
#include <ppl.h>
#include <iostream>
using namespace concurrency;
using namespace std;
int wmain()
{
single_assignment<int> buffer;
int result;
try
{
// Run two tasks in parallel.
parallel_invoke(
// This task waits 5 seconds and then sends a message to
// the message buffer.
[&] {
wait(5000);
send(buffer, 42);
},
// This task waits 3 seconds to receive a message.
// The receive function throws operation_timed_out if it does
// not receive a message in the specified time period.
[&] {
result = receive(buffer, 3000);
}
);
// Print the result.
wcout << L"The result is " << result << endl;
}
catch (operation_timed_out&)
{
wcout << L"The operation timed out." << endl;
}
}
Bu örnek aşağıdaki çıkışı oluşturur.
The operation timed out.
Uygulamanızın anormal şekilde sonlandırılmasını önlemek için kodunuzun çalışma zamanını çağırdığında özel durumları işlediğinden emin olun. Ayrıca Eşzamanlılık Çalışma Zamanı'nı kullanan dış koda(örneğin, bir üçüncü taraf kitaplığı) çağırdığınızda özel durumları işleyin.
[Üst]
Birden Çok Özel Durum
Bir görev veya paralel algoritma birden çok özel durum alıyorsa, çalışma zamanı bu özel durumlardan yalnızca birini çağıran bağlama göre sıralar. Çalışma zamanı hangi özel durumu sıraladığını garanti etmez.
Aşağıdaki örnek, sayıları konsola parallel_for yazdırmak için algoritmayı kullanır. Giriş değeri bir minimum değerden küçükse veya bir en büyük değerden büyükse bir özel durum oluşturur. Bu örnekte, birden çok iş işlevi özel durum oluşturabilir.
// eh-multiple.cpp
// compile with: /EHsc
#include <ppl.h>
#include <iostream>
#include <sstream>
using namespace concurrency;
using namespace std;
int wmain()
{
const int min = 0;
const int max = 10;
// Print values in a parallel_for loop. Use a try-catch block to
// handle any exceptions that occur in the loop.
try
{
parallel_for(-5, 20, [min,max](int i)
{
// Throw an exeception if the input value is less than the
// minimum or greater than the maximum.
// Otherwise, print the value to the console.
if (i < min)
{
stringstream ss;
ss << i << ": the value is less than the minimum.";
throw exception(ss.str().c_str());
}
else if (i > max)
{
stringstream ss;
ss << i << ": the value is greater than than the maximum.";
throw exception(ss.str().c_str());
}
else
{
wstringstream ss;
ss << i << endl;
wcout << ss.str();
}
});
}
catch (exception& e)
{
// Print the error to the console.
wcerr << L"Caught exception: " << e.what() << endl;
}
}
Aşağıdaki örnekte bu örneğe yönelik örnek çıktı gösterilmektedir.
8293104567Caught exception: -5: the value is less than the minimum.
[Üst]
İptal
Tüm özel durumlar bir hataya işaret etmemektedir. Örneğin, bir arama algoritması, sonucu bulduğunda ilişkili görevini durdurmak için özel durum işlemeyi kullanabilir. Kodunuzda iptal mekanizmalarını kullanma hakkında daha fazla bilgi için bkz . PPL'de İptal.
[Üst]
Basit Görevler
Basit görev, doğrudan eşzamanlılık::Scheduler nesnesinden zamanladığınız bir görevdir. Basit görevler sıradan görevlerden daha az yük taşır. Ancak, çalışma zamanı basit görevler tarafından oluşan özel durumları yakalamaz. Bunun yerine, özel durum, varsayılan olarak işlemi sonlandıran işlenmeyen özel durum işleyicisi tarafından yakalanılır. Bu nedenle, uygulamanızda uygun bir hata işleme mekanizması kullanın. Basit görevler hakkında daha fazla bilgi için bkz . Görev Zamanlayıcı.
[Üst]
Zaman Uyumsuz Aracılar
Basit görevler gibi çalışma zamanı da zaman uyumsuz aracılar tarafından oluşan özel durumları yönetmez.
Aşağıdaki örnekte, eşzamanlılık::agent öğesinden türetilen bir sınıftaki özel durumları işlemenin bir yolu gösterilmektedir. Bu örnek sınıfı tanımlar points_agent . yöntemi, points_agent::run nesneleri ileti arabelleğinden okur point ve konsola yazdırır. yöntemi run bir işaretçi alırsa bir NULL özel durum oluşturur.
run yöntemi tüm işleri bir try-catch blok içinde çevreler. blok, catch özel durumu bir ileti arabelleğinde depolar. Uygulama, aracı tamamlandıktan sonra bu arabellekten okuyarak aracının bir hatayla karşılaşıp karşılaşmadığını denetler.
// eh-agents.cpp
// compile with: /EHsc
#include <agents.h>
#include <iostream>
using namespace concurrency;
using namespace std;
// Defines a point with x and y coordinates.
struct point
{
int X;
int Y;
};
// Informs the agent to end processing.
point sentinel = {0,0};
// An agent that prints point objects to the console.
class point_agent : public agent
{
public:
explicit point_agent(unbounded_buffer<point*>& points)
: _points(points)
{
}
// Retrieves any exception that occurred in the agent.
bool get_error(exception& e)
{
return try_receive(_error, e);
}
protected:
// Performs the work of the agent.
void run()
{
// Perform processing in a try block.
try
{
// Read from the buffer until we reach the sentinel value.
while (true)
{
// Read a value from the message buffer.
point* r = receive(_points);
// In this example, it is an error to receive a
// NULL point pointer. In this case, throw an exception.
if (r == NULL)
{
throw exception("point must not be NULL");
}
// Break from the loop if we receive the
// sentinel value.
else if (r == &sentinel)
{
break;
}
// Otherwise, do something with the point.
else
{
// Print the point to the console.
wcout << L"X: " << r->X << L" Y: " << r->Y << endl;
}
}
}
// Store the error in the message buffer.
catch (exception& e)
{
send(_error, e);
}
// Set the agent status to done.
done();
}
private:
// A message buffer that receives point objects.
unbounded_buffer<point*>& _points;
// A message buffer that stores error information.
single_assignment<exception> _error;
};
int wmain()
{
// Create a message buffer so that we can communicate with
// the agent.
unbounded_buffer<point*> buffer;
// Create and start a point_agent object.
point_agent a(buffer);
a.start();
// Send several points to the agent.
point r1 = {10, 20};
point r2 = {20, 30};
point r3 = {30, 40};
send(buffer, &r1);
send(buffer, &r2);
// To illustrate exception handling, send the NULL pointer to the agent.
send(buffer, reinterpret_cast<point*>(NULL));
send(buffer, &r3);
send(buffer, &sentinel);
// Wait for the agent to finish.
agent::wait(&a);
// Check whether the agent encountered an error.
exception e;
if (a.get_error(e))
{
cout << "error occurred in agent: " << e.what() << endl;
}
// Print out agent status.
wcout << L"the status of the agent is: ";
switch (a.status())
{
case agent_created:
wcout << L"created";
break;
case agent_runnable:
wcout << L"runnable";
break;
case agent_started:
wcout << L"started";
break;
case agent_done:
wcout << L"done";
break;
case agent_canceled:
wcout << L"canceled";
break;
default:
wcout << L"unknown";
break;
}
wcout << endl;
}
Bu örnek aşağıdaki çıkışı oluşturur.
X: 10 Y: 20
X: 20 Y: 30
error occurred in agent: point must not be NULL
the status of the agent is: done
Blok döngünün try-catch dışında bulunduğundan while , aracı ilk hatayla karşılaştığında işlemeyi sonlandırır. Blok döngünün try-catchwhile içindeyse, bir hata oluştuktan sonra aracı devam eder.
Bu örnek, başka bir bileşenin aracıyı çalışırken hataları izleyebilmesi için özel durumları bir ileti arabelleğinde depolar. Bu örnekte hatayı depolamak için eşzamanlılık ::single_assignment nesnesi kullanılır. Bir aracının birden çok özel durumu işlemesi durumunda, single_assignment sınıfı yalnızca ona geçirilen ilk iletiyi depolar. Yalnızca son özel durumu depolamak için concurrency::overwrite_buffer sınıfını kullanın. Tüm özel durumları depolamak için concurrency::unbounded_buffer sınıfını kullanın. Bu ileti blokları hakkında daha fazla bilgi için bkz . Zaman Uyumsuz İleti Blokları.
Zaman uyumsuz aracılar hakkında daha fazla bilgi için bkz . Zaman Uyumsuz Aracılar.
[Üst]
Özet
[Üst]
Ayrıca bkz.
Eşzamanlılık Çalışma Zamanı
Görev Paralelliği
Paralel Algoritmalar
PPL'de İptal
Görev Zamanlayıcı
Zaman Uyumsuz Aracılar
Geri Bildirim
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz. https://aka.ms/ContentUserFeedback.
Gönderin ve geri bildirimi görüntüleyin