Qu'est-ce qu'un livelock?

Livelock est un état similaire à deadlock, mais au lieu de bloquer les threads, ils tentent constamment d'effectuer leur travail, en annulant mutuellement leurs actions en raison de la concurrence pour les ressources, ce qui empêche leur progression.

Exemple de livelock : deux threads tentent d'obtenir deux ressources A et B. Thread 1 :

1. Obtient la ressource A.
2. Essaie d'obtenir la ressource B. Si cela échoue, libère A et recommence.

Thread 2 :

1. Obtient la ressource B.
2. Essaie d'obtenir la ressource A. Si cela échoue, libère B et recommence.

En conséquence, les threads peuvent libérer constamment les ressources et réessayer de les obtenir, sans atteindre leur objectif.

Différences avec deadlock :

• Deadlock : les threads sont bloqués, attendant les uns les autres.
• Livelock : les threads travaillent activement, mais ne progressent pas.

Prévention :

• Accès ordonné aux ressources.
• Délais d'attente lors de la tentative d'obtention d'une ressource.
• Éviter les dépendances complexes entre ressources.

Exemple de pseudocode avec tentative de livelock :

// Ressource 1
let resource1 = NSLock()
// Ressource 2
let resource2 = NSLock()

// Thread 1
DispatchQueue.global().async {
    while true {
        resource1.lock()
        if resource2.tryLock() {
            // Ressources obtenues avec succès
            // Effectuer le travail
            print("Thread 1 effectue le travail")
            resource2.unlock()
            resource1.unlock()
            break // Fin de la boucle après succès
        } else {
            // Échec pour obtenir resource2, libérer resource1 et réessayer
            resource1.unlock()
            // Petite pause pour éviter les tentatives immédiates
            Thread.sleep(forTimeInterval: 0.01)
        }
    }
}

// Thread 2
DispatchQueue.global().async {
    while true {
        resource2.lock()
        if resource1.tryLock() {
            // Ressources obtenues avec succès
            // Effectuer le travail
            print("Thread 2 effectue le travail")
            resource1.unlock()
            resource2.unlock()
            break // Fin de la boucle après succès
        } else {
            // Échec pour obtenir resource1, libérer resource2 et réessayer
            resource2.unlock()
            // Petite pause
            Thread.sleep(forTimeInterval: 0.01)
        }
    }
}