Impasse dans la programmation simultanée C++ et stratégies pour éviter les impasses ?

Un blocage se produit lorsqu'un thread tombe dans un état d'attente circulaire en attendant que d'autres threads libèrent des ressources. Les stratégies pour éviter les impasses comprennent : Éviter l'attente en boucle Utilisation ordonnée des ressources Stratégie de délai d'attente Dans le problème des philosophes de la salle à manger, l'utilisation ordonnée des ressources des baguettes (baguette gauche en premier) résout le problème de l'impasse.

Interblocage dans la programmation simultanée C++ et stratégies pour éviter les blocages

Qu'est-ce qu'un blocage ?

En programmation simultanée, un blocage se produit lorsque plusieurs threads attendent que d'autres threads libèrent des ressources en même temps. Cela provoque le blocage du thread indéfiniment, incapable de poursuivre l'exécution.

Stratégies pour éviter les impasses

Il existe plusieurs stratégies pour éviter les impasses :

• Éviter l'attente circulaire : Assurez-vous que les threads ne forment pas une relation d'attente circulaire en attendant que d'autres threads libèrent des ressources.
• Utilisation ordonnée des ressources : Établissez un ordre d'acquisition fixe pour toutes les ressources et forcez tous les threads à acquérir des ressources dans cet ordre.
• Stratégie de délai d'attente : Définissez un délai d'attente pour l'obtention des ressources. Lorsque le thread ne peut pas obtenir de ressources dans le délai d'attente, les ressources seront libérées.

Cas pratique : Le problème des philosophes à manger

Le problème des philosophes à manger est un problème d'impasse classique. Il y a 5 philosophes assis autour d’une table ronde, chacun avec une baguette. Ils peuvent manger avec deux baguettes à gauche et à droite à tout moment, mais ils ne peuvent prendre qu'une seule baguette à la fois. Si tous les philosophes prennent la baguette de gauche en même temps, ils se retrouveront tous dans une impasse.

Nous pouvons utiliser la stratégie d'utilisation ordonnée des ressources pour résoudre ce problème :

// 筷子类
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;
}

Dans cet exemple, nous créons un std::mutexmutex pour chaque baguette, garantissant qu'un seul philosophe peut accéder à la baguette à la fois. En mettant les baguettes en ordre, on évite une impasse.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!