Pengaturcaraan Serentak C++: Bagaimana untuk mengelakkan kebuluran benang dan penyongsangan keutamaan?

Untuk mengelakkan kebuluran benang, anda boleh menggunakan kunci yang adil untuk memastikan peruntukan sumber yang adil, atau menetapkan keutamaan benang. Untuk menyelesaikan penyongsangan keutamaan, anda boleh menggunakan warisan keutamaan, yang meningkatkan keutamaan utas yang memegang sumber buat sementara waktu atau menggunakan promosi kunci, yang meningkatkan keutamaan utas yang memerlukan sumber.

Pengaturcaraan Serentak C++: Elakkan Kebuluran Benang dan Penyongsangan Keutamaan

Dalam pengaturcaraan serentak, kebuluran benang dan penyongsangan keutamaan adalah cabaran biasa yang mungkin membawa kepada kebuntuan dan ketidakpastian. Artikel ini meneroka isu ini dan menyediakan penyelesaian, digambarkan dengan contoh praktikal.

Kebuluran benang

Kebuluran benang berlaku apabila benang tidak dapat memperoleh sumber yang diperlukan (seperti kunci, ingatan) untuk masa yang lama. Ini mungkin disebabkan oleh urutan lain yang mengakses sumber terlebih dahulu. .

Tetapkan keutamaan utas: Peruntukkan lebih banyak peluang pelaksanaan kepada utas keutamaan tinggi untuk memastikan ia tidak disekat oleh utas keutamaan rendah.

• Penyongsangan Keutamaan
• Penyongsangan keutamaan berlaku apabila utas keutamaan yang lebih rendah memegang sumber yang diperlukan oleh utas keutamaan yang lebih tinggi. Ini boleh menyebabkan urutan keutamaan tinggi tidak dapat dilaksanakan, sekali gus melambatkan penyiapan tugas.
Strategi penyelesaian:

Gunakan warisan keutamaan:

Apabila benang memegang sumber, keutamaannya akan ditingkatkan buat sementara waktu untuk menghalang benang keutamaan rendah daripada merebut sumber.

Gunakan promosi kunci: Apabila utas perlu mengakses sumber yang dipegang oleh utas keutamaan tinggi, ia akan meningkatkan keutamaannya buat sementara waktu untuk mendapatkan sumber itu dengan cepat.

• Kes Praktikal
• Pertimbangkan senario berikut:

  // Thread 1 (low priority)
  void thread1() {
    std::mutex m;
    m.lock();
    // Critical section
    m.unlock();
  }
  
  // Thread 2 (high priority)
  void thread2() {
    std::mutex m;
    m.lock();
    // Critical section
    m.unlock();
  }

  Andaikan thread2 berjalan dengan keutamaan yang lebih tinggi daripada thread1. Jika thread1 memperoleh kunci terlebih dahulu dan memasuki bahagian kritikal, thread2 mungkin disekat. Apabila benang1 melepaskan kunci, benang2 mungkin masih tidak dapat memperoleh kunci kerana benang1 mempunyai keutamaan yang lebih rendah dan akan merampas kunci itu semula. Ini menyebabkan thread2 kelaparan.

Untuk menyelesaikan masalah ini, warisan keutamaan boleh digunakan:

void set_thread_priority(Thread thread, int priority);

void thread1() {
  std::mutex m;
  m.lock();
  // Critical section

  // Boost thread priority while holding lock
  set_thread_priority(std::this_thread::get_id(), 2);
  m.unlock();
}

Kesimpulan

Dengan memahami kebuluran benang dan penyongsangan keutamaan serta menggunakan strategi penyelesaian yang sesuai, prestasi dan kebolehpercayaan kod serentak boleh dipertingkatkan dengan ketara.

Atas ialah kandungan terperinci Pengaturcaraan Serentak C++: Bagaimana untuk mengelakkan kebuluran benang dan penyongsangan keutamaan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!