Come capire questo machanizion bloccaggio CCAS utilizzato in AKKA?

Question

Ho appena imbattuto in un pezzo di codice in Akka.

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

I metodi principali Sono interessato a è elencato di seguito.

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

Ci sono due subquestions correlati.

1) Qual è scopo di questa classe SimpleLock

2) Qualsiasi suggerimenti o conoscenze di base su come funziona?

Credo che dal momento che questo codice è scritto in Java e Scala, sfrutta la classe AtomicBoolean. Così mi piacerebbe aggiungere tag java anche.

Qualsiasi consiglio è benvenuto! Non capisco perché qualcuno voto a questa domanda vicino.

Correlati:

Qualcuno può interpretare questo codice C ++ ( da openjdk6) in parole povere?

Answer 1

Ecco la mia comprensione del codice. Si utilizza un acquisita (AtomicBoolean) come mutex. Se una qualsiasi thread tenta di acquisire il blocco, allora sarà set acquisito per essere vero. quindi qualsiasi altro thread non può acquisito il blocco a causa di che riceveranno il vero dal falso acquisito e restituito fino a quando questo acquisita è tornato insieme a false da questo thread.

Dal momento che non è acquisito da una collezione, non avrà problemi ABA. Così si può lavorare.

Si prega di correggetemi se sbaglio.