Heim > Artikel > Backend-Entwicklung > 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:
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
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!