Deadlock in der gleichzeitigen C++-Programmierung und Strategien zur Vermeidung von Deadlocks?

Deadlock tritt auf, wenn ein Thread in einen zirkulären Wartezustand gerät, während er darauf wartet, dass andere Threads Ressourcen freigeben. Zu den Strategien zur Vermeidung von Deadlocks gehören: Vermeidung von Schleifenwartezeiten, geordnete Nutzung von Ressourcen, Timeout-Strategie. Beim Problem der Essensphilosophen löst die geordnete Nutzung der Stäbchenressourcen (linkes Stäbchen zuerst) das Deadlock-Problem.

Deadlock in der gleichzeitigen C++-Programmierung und Strategien zur Vermeidung von Deadlocks

Was ist Deadlock?

Bei der gleichzeitigen Programmierung kommt es zu einem Deadlock, wenn mehrere Threads darauf warten, dass andere Threads gleichzeitig Ressourcen freigeben. Dies führt dazu, dass der Thread auf unbestimmte Zeit blockiert und die Ausführung nicht fortgesetzt werden kann.

Strategien zur Vermeidung von Deadlocks

Es gibt mehrere Strategien zur Vermeidung von Deadlocks:

• Zirkuläres Warten vermeiden: Stellen Sie sicher, dass Threads keine zirkuläre Wartebeziehung bilden, indem Sie darauf warten, dass andere Threads Ressourcen freigeben.
• Geordnete Ressourcennutzung: Legen Sie eine feste Beschaffungsreihenfolge für alle Ressourcen fest und zwingen Sie alle Threads, Ressourcen in dieser Reihenfolge zu erwerben.
• Timeout-Strategie: Legen Sie ein Timeout für den Ressourcenabruf fest. Wenn der Thread die Ressource nicht innerhalb des Timeout-Zeitraums abrufen kann, wird die Ressource freigegeben.

Praktischer Fall: Das Restaurant-Philosophen-Problem

Das Restaurant-Philosophen-Problem ist ein klassisches Deadlock-Problem. An einem runden Tisch sitzen 5 Philosophen, jeder mit einem Essstäbchen. Sie können jederzeit mit zwei Stäbchen links und rechts essen, aber sie können immer nur ein Stäbchen gleichzeitig nehmen. Wenn alle Philosophen gleichzeitig das linke Stäbchen in die Hand nehmen, geraten sie alle in eine Sackgasse.

Wir können die Strategie „geordnete Ressourcennutzung“ verwenden, um dieses Problem zu lösen:

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

In diesem Beispiel erstellen wir einen

Mutex für jedes Stäbchen, um sicherzustellen, dass jeweils nur ein Philosoph auf das Stäbchen zugreifen kann. Indem wir die Stäbchen in Ordnung bringen, vermeiden wir einen Stillstand.

Das obige ist der detaillierte Inhalt vonDeadlock in der gleichzeitigen C++-Programmierung und Strategien zur Vermeidung von Deadlocks?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!