Comment Scala parvient-elle à éviter la course dans la programmation réactive?

Question

Comme je l'ai réalisé jusqu'à ce moment l'idée de base pour la programmation réactive fonctionnelle Scala est de définir un signal qui étend la classe DynamicVariable de Scala, mais je ne pouvais pas comprendre quelque chose d'écrit pour expliquer cette classe, il a dit:

DynamicVariables fournissent un mécanisme de liaison lorsque la valeur actuelle est trouvée par la portée dynamique, mais où l'accès à la variable elle-même est résolu par la portée statique.

Si je ne me trompe pas, la portée dynamique est quand une fonction appelée voit une variable du champ d'application du programme de l'appelant et la portée statique est quand il voit une variable de sa propre portée comme le pseudo-code suit:

let x = 1 
    func dynamic (y: Int) = y + x 
    func static (w: Int) = y + x 
    func main() = { 
     let x = 2 
     dynamic (3) //returns 5 
     static (3) //returns 4 
    } 

la question est de savoir comment est le sens de l'accès à la variable elle-même, et si elle implique écrit, comment Scala éviter les courses lorsque certaines fonctions ont chacun une copie et que vous voulez écrire à la variable?

Answer 1

Dans ce qui suit, dv1 est défini de façon normale, et est accessible uniquement par les règles de portée habituelles. La fonction checkDv1 voit dv1 parce dv1 est défini dans son champ d'application.

val dv1: DynamicVariable[Int] = new DynamicVariable(42) 

def checkDv1 = println(dv1.value) 

Toutefois, lorsque checkDv1 est invoqué à l'intérieur du champ dynamique withValue(), la valeur qu'il revient est différent, comme ce sera la nouvelle valeur liée.

def testDv = dv1.withValue(41) { 
    checkDv1 
} 

checkDv1 
testDv 
checkDv1 

Ainsi, la sortie de ces trois invocations de fonction doit être:

42 
41 
42 

que les changements de périmètre dynamiques.

Pour votre autre question, un DynamicVariable a une fixation dans le contexte d'un fil. Lorsqu'un nouveau thread est créé, la liaison en cours est copiée dans le nouveau thread, et ils n'ont plus aucune interaction entre eux. Par conséquent, pas de conditions de course.

DynamicVariable a très peu à voir avec la programmation réactive, sauf que son comportement est bien défini dans un environnement multi-thread.