Comment comprendre ce machanizion de verrouillage CCAS utilisé dans AKKA?

Question

Je viens de tomber sur un morceau de code dans akka.

https://codereview.scala-lang.org/fisheye/browse/~raw,r=25521/scala-svn/scala/trunk/test/files/presentation/akka/src/akka/util/LockUtil.scala

Les méthodes de base que je suis intéressé est indiqué ci-dessous.

/** 
* A very simple lock that uses CCAS (Compare Compare-And-Swap) 
* Does not keep track of the owner and isn't Reentrant, so don't nest and try to stick to the if*-methods 
*/ 
class SimpleLock { 
    val acquired = new AtomicBoolean(false) 

    def ifPossible(perform:() => Unit): Boolean = { 
    if (tryLock()) { 
     try { 
     perform 
     } finally { 
     unlock() 
     } 
     true 
    } else false 
    } 



    def tryLock() = { 
    if (acquired.get) false 
    else acquired.compareAndSet(false, true) 
    } 

    def tryUnlock() = { 
    acquired.compareAndSet(true, false) 
    } 

Il existe deux sous-questions connexes.

1) Quel est objectif de cette classe SimpleLock

2) Tous les conseils ou les connaissances de base sur la façon dont cela fonctionne?

Je pense que puisque ce code est écrit à la fois dans JAVA et scala, il exploite la classe AtomicBoolean. Donc, j'ajouterais java tag aussi.

Tout conseil est le bienvenu! Je ne sais pas pourquoi quelqu'un vote cette question à proximité.

connexes:

Can anyone interpret this C++ code (from OpenJDK6) into plain English?

Answer 1

Voici ma compréhension du code. Il a utilisé un acquis (AtomicBoolean) comme mutex. Si un thread essaye d'acquérir le verrou, alors il passera à true. alors n'importe quel autre thread ne peut pas acquérir le verrou en raison de ce qu'ils deviendront vrais d'acquis et retournés faux jusqu'à ce que cet acquis soit remis à faux par ce fil.

Depuis acquis n'est pas d'une collection, il n'aura pas de problème ABA. Donc ça peut marcher.

Corrigez-moi si je me trompe.