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

Question

Je viens suis tombé sur un morceau de code à 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 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 y a deux sous-questions connexes.

1) Quel est objectif de cette classe SimpleLock

2) Tout conseils ou des connaissances générales sur la façon dont cela fonctionne?

Je pense que puisque ce code est écrit en Java et scala, il tire parti de la classe AtomicBoolean. Donc, j'ajouter java tag aussi.

Un conseil est le bienvenu! Je ne sais pas pourquoi quelqu'un vote cette question proche.

associés:

Quelqu'un peut-il interpréter ce code C ++ ( de OpenJDK6) en anglais plaine

Answer 1

Voici ma compréhension du code. Il a utilisé un acquis (AtomicBoolean) comme mutex. Si un thread tente d'acquérir le verrou, puis il sera mis a acquis pour être vrai. puis tout autre thread ne peut pas acquérir le verrou en raison de ils obtiennent le vrai du faux acquis et retourné jusqu'à ce acquis est remis à faux par ce fil.

Depuis l'acquisition ne provient pas d'une collection, il n'aura pas problème de l'ABA. Il peut donc fonctionner.

S'il vous plaît me corriger si je me trompe.