Bagaimana untuk menyelesaikan masalah kebuntuan biasa dalam pengaturcaraan berbilang benang C++?

Bagaimana untuk menyelesaikan masalah kebuntuan biasa dalam pengaturcaraan berbilang benang C++? Teknik untuk mengelakkan kebuntuan: Susunan kunci: Sentiasa dapatkan kunci dalam susunan yang sama. Pengesanan jalan buntu: Gunakan algoritma untuk mengesan dan menyelesaikan kebuntuan. Tamat masa: Tetapkan nilai tamat masa untuk kunci untuk mengelakkan benang menunggu selama-lamanya. Penyongsangan keutamaan: Tetapkan keutamaan yang berbeza untuk mengurangkan kemungkinan kebuntuan.

Cara menyelesaikan masalah kebuntuan biasa dalam pengaturcaraan berbilang benang C++

Gambaran Keseluruhan Kebuntuan

Kebuntuan ialah ralat pengaturcaraan di mana dua atau lebih utas disekat selama-lamanya, menunggu satu sama lain melepaskan kunci. Ini biasanya disebabkan oleh kunci bergantung kitaran, di mana satu benang memegang kunci A dan menunggu kunci B, manakala satu lagi benang memegang kunci B dan menunggu kunci A.

Teknik untuk mengelakkan kebuntuan

Berikut adalah teknik biasa untuk mengelakkan kebuntuan:

• Perintah perolehan kunci: Sentiasa dapatkan kunci dalam susunan yang sama. Ini membantu mengelakkan kebergantungan bulat.
• Pengesanan Jalan Mati: Gunakan algoritma pengesanan jalan buntu untuk mengesan dan menyelesaikan kebuntuan.
• Tamat masa: Tetapkan nilai tamat masa untuk kunci untuk mengelakkan benang menunggu selama-lamanya.
• Penyongsangan Keutamaan: Tetapkan keutamaan berbeza pada benang untuk mengurangkan kemungkinan kebuntuan.

Kes Praktikal

Mari kita ambil contoh kod berikut di mana dua utas cuba mengakses sumber yang dikongsi:

class Resource {
public:
    void increment() {
        std::lock_guard<std::mutex> lock(m_mutex);
        ++m_value;
    }
    int m_value = 0;
    std::mutex m_mutex;
};

int main() {
    Resource resource;
    std::thread thread1([&resource] { resource.increment(); });
    std::thread thread2([&resource] { resource.increment(); });
    thread1.join();
    thread2.join();
}

Dalam contoh ini, utas 1 dan 2 cuba memperoleh kunci yang sama (resource.m_mutex) untuk mengemas kini pembolehubah <code>m_value. Jika benang 1 memperoleh kunci terlebih dahulu, benang 2 akan disekat, dan sebaliknya. Ini boleh menyebabkan kebergantungan bulat dan kebuntuan. resource.m_mutex) 来更新 m_value 变量。如果线程 1 先获取锁，则线程 2 将被阻止，反之亦然。这可能会导致循环依赖和死锁。

解决方法

为了修复此问题，我们可以使用加锁顺序。例如，我们可以让所有线程先获取 resource.m_mutex 锁，再获取 m_value

Penyelesaian

Untuk menyelesaikan masalah ini, kita boleh menggunakan perintah mengunci. Sebagai contoh, kita boleh membenarkan semua urutan memperoleh kunci resource.m_mutex dahulu, dan kemudian memperoleh kunci m_value: 🎜

class Resource {
public:
    void increment() {
        std::lock(m_mutex, m_value_mutex);
        ++m_value;
        std::unlock(m_value_mutex, m_mutex);
    }
    int m_value = 0;
    std::mutex m_mutex;
    std::mutex m_value_mutex;
};

int main() {
    Resource resource;
    std::thread thread1([&resource] { resource.increment(); });
    std::thread thread2([&resource] { resource.increment(); });
    thread1.join();
    thread2.join();
}

🎜Dengan cara ini, kedua-dua utas akan memperoleh kunci dalam susunan yang sama, dengan itu Elakkan kebuntuan. 🎜

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan masalah kebuntuan biasa dalam pengaturcaraan berbilang benang C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!