Konteks

Dokumen ini menjelaskan peran konteks dalam Concurrency Runtime. Utas yang dilampirkan ke penjadwal dikenal sebagai konteks eksekusi, atau hanya konteks. Fungsi konkurensi::tunggu dan konkurensi::Kelas konteks memungkinkan Anda mengontrol perilaku konteks. wait Gunakan fungsi untuk menangguhkan konteks saat ini untuk waktu yang ditentukan. Gunakan kelas Context ketika Anda membutuhkan lebih banyak kontrol saat konteks memblokir, membuka blokir, dan menghentikan, atau ketika Anda ingin melebihi kapasitas penggunaan konteks saat ini.

Petunjuk / Saran

Runtime Konkurensi menyediakan penjadwal bawaan, jadi Anda tidak perlu membuatnya di aplikasi Anda. Karena Task Scheduler membantu Anda menyempurnakan performa aplikasi Anda, kami sarankan Anda memulai dengan Pustaka Pola Paralel (PPL) atau Pustaka Agen Asinkron jika Anda baru menggunakan Concurrency Runtime.

Fungsi tunggu

Fungsi konkurensi::tunggu secara kooperatif menghasilkan eksekusi konteks saat ini untuk sejumlah milidetik yang ditentukan. Runtime menggunakan waktu hasil untuk melakukan tugas lain. Setelah waktu yang ditentukan berlalu, runtime menjadwalkan ulang konteks untuk eksekusi. Oleh karena itu, fungsi wait mungkin menangguhkan konteks saat ini lebih lama dari nilai yang disediakan untuk parameter milliseconds.

Mengoper 0 (nol) untuk milliseconds sebagai parameter ini menyebabkan runtime menangguhkan konteks yang sedang berjalan hingga semua konteks aktif lainnya diberi kesempatan untuk menjalankan tugas yang ada. Ini memungkinkan Anda mengalihkan proses ke semua proses aktif lainnya.

Contoh

Untuk contoh yang menggunakan wait fungsi untuk menghasilkan konteks saat ini, dan dengan demikian memungkinkan konteks lain dijalankan, lihat Cara: Menggunakan Grup Jadwal untuk Memengaruhi Urutan Eksekusi.

Kelas Konteks

Kelas konkurensi::Konteks menyediakan abstraksi pemrograman untuk konteks eksekusi dan menawarkan dua fitur penting: kemampuan untuk secara kooperatif memblokir, membuka blokir, dan menghasilkan konteks saat ini, dan kemampuan untuk kelebihan langganan konteks saat ini.

Pemblokiran Kooperatif

Kelas ini Context memungkinkan Anda memblokir atau menghasilkan konteks eksekusi saat ini. Pemblokiran atau menunggu berguna ketika konteks saat ini tidak dapat dilanjutkan karena sumber daya belum tersedia.

Metode konkurensi::Context::Block memblokir konteks saat ini. Konteks yang diblokir menghasilkan sumber daya pemrosesannya sehingga runtime dapat melakukan tugas lain. Metode konkurensi::Konteks::Unblock membatalkan pemblokiran konteks yang diblokir. Metode Context::Unblock harus dipanggil dari konteks yang berbeda dari yang disebut Context::Block. Runtime melempar konkurensi::context_self_unblock jika konteks mencoba membuka blokir itu sendiri.

Untuk memblokir dan membuka blokir konteks secara kooperatif, Anda biasanya memanggil concurrency::Context::CurrentContext untuk mengambil pointer dari objek Context yang terkait dengan utas saat ini dan menyimpan hasilnya. Anda kemudian memanggil Context::Block metode untuk memblokir konteks saat ini. Kemudian, panggil Context::Unblock dari konteks terpisah untuk membuka blokir konteks yang diblokir.

Anda harus mencocokkan setiap pasangan panggilan dengan Context::Block dan Context::Unblock. Lingkungan runtime akan melempar konkurensi::context_unblock_unbalanced ketika metode Context::Block atau Context::Unblock dipanggil secara berturut-turut tanpa panggilan yang cocok ke metode lainnya. Namun, Anda tidak perlu menelepon Context::Block sebelum memanggil Context::Unblock. Misalnya, jika satu konteks memanggil Context::Unblock sebelum konteks lain memanggil Context::Block konteks yang sama, konteks tersebut tetap tidak diblokir.

Metode konkurensi::Context::Yield menghasilkan eksekusi sehingga runtime dapat melakukan tugas lain dan kemudian menjadwalkan ulang konteks untuk eksekusi. Saat Anda memanggil metode Context::Block, runtime tidak menjadwalkan ulang konteks.

Contoh

Misalnya yang menggunakan Context::Block, Context::Unblock, dan Context::Yield metode untuk mengimplementasikan kelas semaphore kooperatif, lihat Cara: Menggunakan Kelas Konteks untuk Menerapkan Kelas Semaphore Kooperatif.

Permintaan berlebih

Penjadwal bawaan membuat jumlah utas yang setara dengan utas perangkat keras yang tersedia. Anda dapat menggunakan oversubscription untuk membuat utas tambahan untuk utas perangkat keras tertentu.

Untuk operasi yang intensif komputasi, oversubscription biasanya tidak memiliki skala yang baik karena memperkenalkan beban tambahan. Namun, untuk tugas-tugas yang memiliki latensi yang tinggi, misalnya membaca data dari disk atau dari koneksi jaringan, oversubscription dapat meningkatkan efisiensi keseluruhan dari beberapa aplikasi.

Catatan

Aktifkan oversubscription hanya dari utas yang dibuat oleh Concurrency Runtime. Oversubscription tidak memiliki efek ketika dipanggil dari thread yang tidak dibuat oleh runtime (termasuk thread utama).

Untuk mengaktifkan oversubscription dalam konteks saat ini, panggil metode konkruensi Context::Oversubscribe dengan pengaturan parameter _BeginOversubscription ke true. Saat Anda mengaktifkan oversubscription pada utas yang dibuat oleh Concurrency Runtime, runtime akan membuat satu utas tambahan. Setelah semua tugas yang memerlukan oversubscription selesai, panggil Context::Oversubscribe dengan menyetel parameter _BeginOversubscription ke false.

Anda dapat mengaktifkan oversubscription beberapa kali dari konteks saat ini, tetapi Anda harus menonaktifkannya berapa kali Anda mengaktifkannya. Oversubscription juga dapat ditumpuk; artinya, tugas yang dibuat oleh tugas lain yang menggunakan oversubscription juga dapat menggantikan konteksnya. Namun, jika tugas berlapis dan induknya termasuk dalam konteks yang sama, hanya panggilan terluar yang Context::Oversubscribe menyebabkan pembuatan utas tambahan.

Catatan

Runtime melempar konkurensi::invalid_oversubscribe_operation jika oversubscription dinonaktifkan sebelum diaktifkan.

Contoh

Untuk contoh yang menggunakan oversubscription untuk mengimbangi latensi yang disebabkan oleh membaca data dari koneksi jaringan, lihat Cara: Menggunakan Oversubscription untuk Mengimbangi Latensi.

Lihat juga

Penjadwal Tugas
Cara: Menggunakan Grup Jadwal untuk Memengaruhi Urutan Eksekusi
Cara: Menggunakan Kelas Konteks untuk Menerapkan Semaphore Koperatif
Cara: Menggunakan Teknik Oversubscription untuk Mengimbangi Latensi