Heim  >  Artikel  >  Backend-Entwicklung  >  Gleichzeitige C++-Programmierung: Wie erkennt und löst man Deadlock-Probleme?

Gleichzeitige C++-Programmierung: Wie erkennt und löst man Deadlock-Probleme?

WBOY
WBOYOriginal
2024-05-04 17:54:021147Durchsuche

Bei der gleichzeitigen C++-Programmierung tritt das Deadlock-Problem auf, wenn ein oder mehrere Threads unbegrenzt darauf warten, dass andere Threads Ressourcen freigeben, was dazu führt, dass das Programm hängen bleibt. Wir können std::lock_guard und std::unique_lock verwenden, um die Deadlock-Erkennung zu implementieren. Wenn ein Deadlock auftritt, wird eine std::system_error-Ausnahme ausgelöst. Zu den Methoden zum Auflösen von Deadlocks gehören der Erwerb von Sperren in der richtigen Reihenfolge, die Verwendung von zeitgesteuerten Sperren und Algorithmen zur Wiederherstellung von Deadlocks.

Gleichzeitige C++-Programmierung: Wie erkennt und löst man Deadlock-Probleme?

C++-Parallelprogrammierung: Wie man Deadlock-Probleme identifiziert und löst Diese Situation führt dazu, dass das Programm für immer hängen bleibt.

Um den Deadlock zu verstehen, stellen Sie sich das folgende Szenario vor:

Thread A hält Ressource R1 und versucht, Ressource R2 abzurufen.

Thread B hält Ressource R2 und versucht, Ressource R1 zu erhalten.
  • Wenn beide Threads zu diesem Zeitpunkt in den Wartezustand wechseln und darauf warten, dass die andere Partei Ressourcen freigibt, kommt es zu einem Deadlock.
  • Deadlock erkennen

In C++ können wir Sperren wie std::lock_guard und std::unique_lock verwenden, um Ressourcen zu schützen. Diese Sperren implementieren einen Deadlock-Erkennungsmechanismus, und wenn ein Deadlock erkannt wird, wird eine std::system_error-Ausnahme ausgelöst.

Wir können einen Deadlock erkennen, indem wir diese Ausnahme abfangen:

std::mutex m1;
std::mutex m2;

void foo() {
  // 获取锁
  std::lock_guard<std::mutex> lock1(m1);
  std::lock_guard<std::mutex> lock2(m2);

  // 其他操作...
}
int main() {
  try {
    foo();
  } catch (const std::system_error& e) {
    std::cerr << "死锁检测到:异常代码 " << e.code() << std::endl;
  }
}

Wenn beim Ausführen dieses Programms ein Deadlock auftritt, geben wir eine Fehlermeldung aus. std::lock_guardstd::unique_lock 这样的锁保护资源。这些锁实现了死锁检测机制,如果检测到死锁,会抛出 std::system_error 异常。

我们可以通过捕捉此异常来检测死锁:

class BankAccount {
public:
  int balance;
  std::mutex m;
};

void withdraw(BankAccount& account, int amount) {
  std::lock_guard<std::mutex> lock(account.m);
  if (account.balance >= amount)
    account.balance -= amount;
}

void deposit(BankAccount& account, int amount) {
  std::lock_guard<std::mutex> lock(account.m);
  account.balance += amount;
}
void withdraw(BankAccount& account, int amount) {
  std::lock_guard<std::mutex> lock(account.m);
  if (account.balance >= amount)
    account.balance -= amount;
}

void deposit(BankAccount& account, int amount) {
  std::lock_guard<std::mutex> lock(account.m);
  account.balance += amount;
}

如果在运行此程序时发生死锁,我们会打印错误消息。

解决死锁

一旦检测到死锁,就需要解决它。以下是一些常见的解决方案:

  • 按顺序获取锁:通过强制以特定顺序获取锁(例如,始终先获取 R1,然后获取 R2),可以防止死锁。
  • 使用计时锁:计时锁会在一段时间后超时,迫使线程释放资源。
  • 死锁恢复算法:使用专门的算法,比如银行家算法,可以检测和恢复死锁。

实战案例

考虑以下代码,它在两个线程之间共享一个银行账户对象:

rrreee

如果两个线程同时调用 withdrawdeposit

Deadlocks lösen🎜🎜Sobald ein Deadlock erkannt wird, muss er behoben werden. Hier sind einige gängige Lösungen: 🎜🎜🎜Sperren in der richtigen Reihenfolge erwerben: Deadlocks können verhindert werden, indem man erzwingt, dass Sperren in einer bestimmten Reihenfolge erworben werden (z. B. immer zuerst R1 und dann R2 erwerben). 🎜🎜Verwenden Sie Zeitsperren: Zeitsperren werden nach einer gewissen Zeit abgelaufen und zwingen den Thread, Ressourcen freizugeben. 🎜🎜Deadlock-Recovery-Algorithmen: Deadlocks können mithilfe spezieller Algorithmen wie dem Banker-Algorithmus erkannt und wiederhergestellt werden. 🎜🎜🎜Praktischer Fall🎜🎜Betrachten Sie den folgenden Code, der ein Bankkontoobjekt zwischen zwei Threads teilt: 🎜rrreee🎜Wenn zwei Threads gleichzeitig withdraw und deposit aufrufen Funktion kann es zu einem Deadlock kommen. Wir können dieses Problem lösen, indem wir Schlösser in der folgenden Reihenfolge erwerben: 🎜rrreee

Das obige ist der detaillierte Inhalt vonGleichzeitige C++-Programmierung: Wie erkennt und löst man Deadlock-Probleme?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn