¿Cómo entender esta maquanización de bloqueo de CCAS utilizada en Akka?

Question

Acabo de encontrar un código en Akka.

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

Los métodos principales que me interesan se enumeran a continuación.

/**
 * 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)
  }

Hay dos subcondaciones relacionadas.

1) ¿Cuál es el propósito de esta clase SimpleLock?

2) ¿Alguna pista o conocimiento de fondo sobre cómo funciona?

Creo que dado que este código está escrito tanto en Java como en Scala, aprovecha la clase atómica. Así que también agregaría la etiqueta Java.

¡Cualquier consejo es bienvenido! No estoy seguro de por qué alguien vota esta pregunta de cerca.

Relacionado:

¿Alguien puede interpretar este código C ++ (desde OpenJDK6) en inglés sencillo?

Answer 1

Aquí está mi comprensión del código. Utilizó un adquirido (atómico) como un mutex. Si algún hilo intenta adquirir el bloqueo, entonces se establecerá como verdad. Entonces, cualquier otro hilo no puede adquirir el bloqueo debido a que se volverá verdadero de adquirido y devuelto falso hasta que este hilo se retrase a este hilo.

Como adquirido no es de una colección, no tendrá un problema ABA. Entonces puede funcionar.

Por favor, corríjame si estoy equivocado.