Primitives de concurrence dans Scala

Une des solutions possibles de votre tâche est des acteurs. Ce n'est pas la solution la plus rapide mais sûre et simple: xxx

Si vous n'êtes pas disposé à utiliser java.util.concurrent code> directement, votre solution la plus élégante peut utiliser AGENTS AKKA .

import java.util.concurrent.atomic.AtomicInteger

class FooCounter {
  val counter = new AtomicInteger(0)
  def get() = counter.get()
  def set(v: Int) = counter.set(v)
  def inc() = counter.incrementAndGet()
  def modify(f: Int => Int) = {
    var done = false
    var oldVal: Int = 0
    while (!done) {
      oldVal = counter.get()
      done = counter.compareAndSet(oldVal, f(oldVal))
    }
  }
}

Vous devez savoir que votre implémentation de FOOCOUNTER n'est pas du thread-Safe. Si plusieurs threads invoquent simultanément le get , définir et inc méthodes, il n'y a aucune garantie que le compte sera précis. Vous devez utiliser l'un des utilitaires suivants pour mettre en place un compteur concomitable correct:

• Synchronisée instruction (SCALA Synchronisée est similaire à la un en Java )
• Variables atomiques
• STMS (par exemple, scalastm )
• potentiellement, vous pouvez utiliser un acteur AKKA qui est un comptoir, mais noter que ce n'est pas l'application la plus simple des acteurs

  Autres utilitaires de concurrence Scala, tels que contrats à terme et promesses, collections parallèles ou extensions réactives, ne sont pas le mieux adapté à la mise en œuvre d'un compteur simultané et ont des usages différents.

  Vous devez savoir que Scala dans certains cas réutilise l'infrastructure de simultanéité Java. Par exemple, Scala ne fournit pas de variables atomiques à part, car les classes Atomiques Java font déjà le travail. Au lieu de cela, SCALA a pour objectif de fournir des abstractions de concurrence de niveau supérieur, telles que des acteurs, des STMS et des flux d'événements asynchrones.

  Benchmarking

  Pour évaluer l'heure et l'efficacité de votre implémentation de votre implémentation, un bon choix est scalamètre . La documentation en ligne sur le site Web contient des exemples détaillés sur la manière de faire des analyses d'analyse comparative.

  Documentation et bibliothèques de concurrence

  Pendant que AKKA est l'utilitaire de simultanécence scala le plus populaire et le plus documenté, il existe de nombreuses autres implémentations de haute qualité, dont certaines sont plus appropriées pour différentes tâches:

  • Futures et promesses
  • collections parallèles et scalablitz
  • Mémoire transactionnelle logicielle
  • Extensions réactives

    Je pense L'apprentissage de la programmation simultanée à Scala pourrait être une Bon livre pour vous. Il contient une documentation détaillée de différents styles de concurrence dans Scala, ainsi que sur les instructions sur le point de l'utiliser. Les chapitres 5 et 9 traitent également de la benchmarking. Plus précisément, un utilitaire compteur concomitable est décrit, optimisé et rendu évolutif dans le chapitre 9 du livre.

    Disclaimer: Je suis l'auteur.