Programmation simultanée C++ : comment identifier et résoudre les problèmes de blocage ?

Dans la programmation simultanée C++, le problème de blocage se produit lorsqu'un ou plusieurs threads attendent indéfiniment que d'autres threads libèrent des ressources, provoquant le blocage du programme. Nous pouvons utiliser std::lock_guard et std::unique_lock pour implémenter la détection de blocage. Si un blocage se produit, une exception std::system_error sera levée. Les méthodes permettant de résoudre les blocages incluent l'acquisition des verrous dans l'ordre, l'utilisation de verrous temporisés et des algorithmes de récupération des blocages.

Programmation simultanée C++ : Comment identifier et résoudre les problèmes de blocage

Comprendre le blocage

Le blocage est une erreur courante dans la programmation simultanée qui se produit lorsqu'un ou plusieurs threads attendent indéfiniment d'être libérés par d'autres ressources de threads. Cette situation provoque le blocage définitif du programme.

Pour comprendre l'impasse, considérons le scénario suivant :

• Le thread A détient la ressource R1 et tente d'acquérir la ressource R2.
• Le fil B détient la ressource R2 et tente d'obtenir la ressource R1.

Si les deux threads entrent en état d'attente à ce moment-là, en attendant que l'autre partie libère des ressources, une impasse se produira.

Détecter les blocages

En C++, nous pouvons utiliser des verrous comme std::lock_guard et std::unique_lock pour protéger les ressources. Ces verrous implémentent un mécanisme de détection de blocage, et si un blocage est détecté, une exception std::system_error sera levée. std::lock_guard 和 std::unique_lock 这样的锁保护资源。这些锁实现了死锁检测机制，如果检测到死锁，会抛出 std::system_error 异常。

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

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;
  }
}

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

解决死锁

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

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

实战案例

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

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;
}

如果两个线程同时调用 withdraw 和 deposit

Nous pouvons détecter un blocage en détectant cette exception : 🎜

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;
}

rrreee🎜Si un blocage se produit lors de l'exécution de ce programme, nous imprimons un message d'erreur. 🎜🎜Résoudre les impasses🎜🎜Une fois qu'une impasse est détectée, elle doit être résolue. Voici quelques solutions courantes : 🎜🎜🎜Acquérir les verrous dans l'ordre : Les blocages peuvent être évités en forçant l'acquisition des verrous dans un ordre spécifique (par exemple, acquérez toujours R1 en premier, puis R2). 🎜🎜Utiliser des verrous de synchronisation : Les verrous de synchronisation expireront après un certain temps, obligeant le thread à libérer des ressources. 🎜🎜Algorithmes de récupération des impasses : Les blocages peuvent être détectés et récupérés à l'aide d'algorithmes spécialisés, tels que l'algorithme du banquier. 🎜🎜🎜Cas pratique🎜🎜Considérons le code suivant, qui partage un objet compte bancaire entre deux threads : 🎜rrreee🎜Si deux threads appellent retrait et dépôt en même temps fonction, un blocage peut se produire. Nous pouvons résoudre ce problème en acquérant les serrures dans l'ordre : 🎜rrreee

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!