Thread Cancellation dari terjemahan 2

A std joinable: thread dapat kooperatif dibatalkan. Ketika thread membat

alkan, semua hal ini adalah membuang pengecualian tipe thread_canceled. Jadi t
hread dibatalkan dapat membatalkan nya membatalkan hanya dengan menangk
ap (dan tidak kembali
melempar) thread_canceled. Satu thread dapat
meminta thread lain melempar pengecualian thread_canceled dengan sintaks ini
:
std::thread t(f);
t.cancel();

// request that the thread referred to by t cancel

itself

Thread harus mengeksekusi titik pembatalan. Sebuah thread dapat mengh

ubungi cancellation_point ()
std::this_thread::cancellation_point();//
Will
throw
a
thread_canceled exception if // and only if exceptions are enabled,
and if
// someone has called
t.cancel() where t refers

Catatan bahwa thread utama tidak dapat dibatalkan (oleh thread lain) kar
ena pembatalan oleh thread lain hanya dapat dilakukan
melalui std :: thread dan tidak ada cara untuk membuat std :: thread yang meng
acu ke thread adalah utama daftar poin pembatalan dianjurkan.

void std::this_thread::cancellation_point()
void std::this_thread::sleep(std::nanoseconds rel_time)
void std::thread::join()
void std::thread::operator()()
void std::condition<Lock>::wait(Lock&)
template<class Predicate>void std::condition<Lock>::wait(Lock&,
Predicate)
bool std::condition<Lock>::timed_wait(Lock&, std::nanoseconds)
template<classPredicate>void
std::condition<Lock>::timed_wait(Lock&,std::nanoseconds,
Predicate)

Karena pembatalan dinonaktifkan dengan objek kelas, pembatalan dijamin

akan benar diaktifkan apakah ruang lingkup yang
tersisa biasanya, atau dengan pengecualian (apakah atau tidak yang eksepsi thr
ead_canceled. Pembatalan tidak dinonaktifkan selama tumpukan unwinding.
Destructors harus pembatalan aman apakah mereka sedang dieksekusi karena
pengecualian thread_canceled, atau pengecualian lainnya. Dengan demikian
secara
otomatis
menonaktifkan
pembatalan
ketikathread_canceleddilemparkanadalahberlebihan.Dan ada setidaknya satu
kasus sudut mana menyebabkan efek buruk misalnya :
SomeClass::~SomeClass()
{
std::this_thread::disable_cancellation _;
t_.join(); }
or

SomeClass::~SomeClass()
{ try
{ t_.join();
}

catch (...)
{
}

Disable_cancellation lingkup dapat bersarang artinya kode luar dapat

menonaktifkan pembatalan dan kemudian memanggil fungsi lainnya, tanpa takut
bahwa fugnsi fungsi akan menonaktifkan dan kemudian memungkinkn
pembatalan prematur.
void foo() {
std::this_thread::disable_cancellation _;
// cancellation disabled here
... } // cancellation enabled only if it was enabled upon
entering foo
void bar()
{

std::this_thread::disable_cancellation _;
// cancellation disabled here
foo();
// cancellation still disabled here }

bar

// cancellation enabled only if it was enabled upon entering

Jika panggilan thread utama

this_thread :: cancellation_point ()
atau konstruksi dan objek dari tipe this_thread :: . Maka disable cancellation,
tidak ada efeknya. Thread utama tidak dapat dibatalkan. Memiliki fungsi fungsi
yaitu mengabikan thread utama yang memungkinkan kode perpustakaan untuk
menggunakan fugnsi ini tanpa khawatir apakah itu sedang dijalankan di thread
utama atau tidak. Satu dapat meminta izin dari objek disable_cancellationuntuk
sementara mengkatifkan kembali pembatalan dalam ruang lingkup. Hal ini
memerlukan non constdisable_cancellation. objek
void foo() {
std::this_thread::disable_cancellation no_cancel;
A a;
std::this_thread::enable_cancellation cancel_ok(no_cancel);
a.foo();

// this may be cancelled }

// disable cancellation, a.~A(), enable cancellation

Pembatalanenable_cancellation konstruktor hanya beralih ke negara pembatalan

yang berlaku dengan objek disable_cancellation
direferensikan dibangun. Jadi
enable_cancellation
Tidak dibangun dalam lingkup disable_cancellation lain. Jadi ketika fungsi
mengatakan:
void bar () {
std:: this_thread :: disable_cancellation _; foo (); }

Maka tidak mungkin untuk kode dalam fungsi foo mengaktifkan pembatala
n (bahkan jika itu mencoba untuk seperti contoh ini). Untuk mengaktifkan pemba
talan yang disebut fungsi, bar tidak benarbenar memungkinkan pembatalan kecuali dideferensikan disable_cancellation
objek fungsi.
Desain ini telah dibentuk untuk memberikan fleksibilitas untuk menonaktif
kan dan memungkinkan pembatalan, namun
mencegah disengaja memungkinkan saat memanggil kode yang tidak diketahui,
dan untuk mencegah sengaja tidak mengaktifkan
kembali ketika pengecualian merambat melalui tumpukan bingkai.

KESIMPULAN
Jadi kesimpulan yang terdapat dalam paper dengan judul Thread
Launching for C++0X, kita dapat mengetahui dalam C++ bagaimana cara cara
yang dapat digunakan untuk memakai proses thread cancellation. Dan juga kita
dapat mengetahui bahwa thread utama tidak dapat dibatalkan (oleh thread
lainnya ) karena pembatalan oleh thread lain hanya dapat melalui std :: thread
dan tidak ada cara untuk membuat std :: thread yang mengacu ke thread
adalah utama daftar poin pembatalan yang dianjurkan yaitu :

void std::this_thread::cancellation_point()
void std::this_thread::sleep(std::nanoseconds rel_time)
void std::thread::join()
void std::thread::operator()()
void std::condition<Lock>::wait(Lock&)
template<class Predicate>void std::condition<Lock>::wait(Lock&,
Predicate)
bool std::condition<Lock>::timed_wait(Lock&, std::nanoseconds)
template<classPredicate>void
std::condition<Lock>::timed_wait(Lock&,std::nanoseconds,
Predicate)