Kebuntuan dalam pengaturcaraan dan strategi serentak C++ untuk mengelakkan kebuntuan?

Kebuntuan berlaku apabila benang jatuh ke dalam keadaan menunggu bulat sementara menunggu benang lain mengeluarkan sumber. Strategi untuk mengelakkan kebuntuan termasuk: Elakkan menunggu gelung Penggunaan sumber yang teratur Strategi tamat masa Dalam masalah ahli falsafah makan, penggunaan sumber penyepit secara teratur (penyepit kiri dahulu) menyelesaikan masalah kebuntuan.

Kebuntuan dalam pengaturcaraan serentak C++ dan strategi untuk mengelakkan kebuntuan

Apakah kebuntuan?

Dalam pengaturcaraan serentak, kebuntuan berlaku apabila beberapa utas menunggu untuk utas lain mengeluarkan sumber pada masa yang sama. Ini menyebabkan benang disekat selama-lamanya, tidak dapat meneruskan pelaksanaan. .

Penggunaan sumber secara teratur: Tetapkan perintah pemerolehan tetap untuk semua sumber dan paksa semua rangkaian untuk memperoleh sumber dalam pesanan ini.

Strategi tamat masa:

Tetapkan tamat masa untuk mendapatkan sumber Apabila utas tidak dapat memperoleh sumber dalam tempoh tamat masa, sumber akan dikeluarkan.
Kes praktikal: Masalah ahli falsafah makan
• Masalah ahli falsafah makan adalah masalah kebuntuan klasik. Terdapat 5 ahli falsafah duduk mengelilingi meja bulat, masing-masing dengan penyepit. Mereka boleh makan dengan dua penyepit di kiri dan kanan pada bila-bila masa, tetapi mereka hanya boleh mengambil satu penyepit pada masa yang sama. Jika semua ahli falsafah mengambil penyepit kiri pada masa yang sama, mereka semua akan berada dalam kebuntuan.
• Kita boleh menggunakan penggunaan sumber tersusunstrategi untuk menyelesaikan masalah ini:

// 筷子类
class Chopstick {
public:
    Chopstick() {
        m_mutex = new std::mutex;
    }

    ~Chopstick() {
        delete m_mutex;
    }

    void lock() {
        m_mutex->lock();
    }

    void unlock() {
        m_mutex->unlock();
    }

private:
    std::mutex* m_mutex;
};

// 哲学家类
class Philosopher {
public:
    Philosopher(int id, Chopstick* left, Chopstick* right)
        : m_id(id), m_left(left), m_right(right) {}

    void dine() {
        while (true) {
            // 获取左边的筷子
            m_left->lock();

            // 获取右边的筷子
            m_right->lock();

            // 进餐
            std::cout << "哲学家 " << m_id << " 正在进餐" << std::endl;

            // 放下右边的筷子
            m_right->unlock();

            // 放下左边的筷子
            m_left->unlock();
        }
    }

private:
    int m_id;
    Chopstick* m_left;
    Chopstick* m_right;
};

int main() {
    // 创建 5 根筷子
    Chopstick chopsticks[5];

    // 创建 5 个哲学家
    Philosopher philosophers[5] = {
        Philosopher(0, &chopsticks[0], &chopsticks[4]),
        Philosopher(1, &chopsticks[1], &chopsticks[0]),
        Philosopher(2, &chopsticks[2], &chopsticks[1]),
        Philosopher(3, &chopsticks[3], &chopsticks[2]),
        Philosopher(4, &chopsticks[4], &chopsticks[3])
    };

    // 启动哲学家线程
    std::thread threads[5]; 
    for (int i = 0; i < 5; i++) {
        threads[i] = std::thread(&Philosopher::dine, &philosophers[i]);
    }

    // 等待哲学家线程结束
    for (int i = 0; i < 5; i++) {
        threads[i].join();
    }

    return 0;
}

Dalam contoh ini, kami mencipta

mutex untuk setiap penyepit, memastikan hanya seorang ahli falsafah boleh mengakses penyepit pada satu masa. Dengan menyusun penyepit, kita mengelakkan kebuntuan.

Atas ialah kandungan terperinci Kebuntuan dalam pengaturcaraan dan strategi serentak C++ untuk mengelakkan kebuntuan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!