Variable mutable dans un thread thread-safe?

Question

Je veux utiliser des vars mutables définis dans un thread MyT qui étend le Thread de Java dans l'application et l'utilisation sera Thread.currentThread.asInstanceof[MyT] pour référencer et mettre à jour les vars mutables dans celui-ci.

Sera-ce thread-safe?

mise à jour

j'ai écrit une application à l'aide scala sans examen des questions multithreads et que l'on appelle les pires pratiques de l'utilisation des variables mutables dans l'objet (car il est si facile à utiliser pour les débutants!).

Mais maintenant, en quelque sorte le projet s'étend à une application web, que je dois gérer les problèmes de multi-threading. Je n'ai pas le temps de réécrire le code, de refactoriser tous les variables d'objets en arguments (probablement une solution de ne pas utiliser l'objet global mutable vars), donc je pense à déplacer les vars mutables dans l'objet à un Classe de threads qui étend la classe Thread et refactorise le code pour utiliser Thread.currentThread, puis transtyper l'instance dans mon type de thread étendu, puis référencer/mettre à jour les vars modifiables qui sont à l'origine des vars mutables globaux.

Alors voici ma question originale.

Answer 1

Utilisez ThreadLocal à cet effet: http://java.dzone.com/articles/java-thread-local-%E2%80%93-how-use

Answer 2

Si vous seulement interagissez avec les variables mutables de l'intérieur du fil lui-même (le cas Thread.currentThread.asInstanceof[MyT] d'utilisation que vous avez mentionné), il est thread-safe (et généralement plus rapide que ThreadLocal).

Si vous interagissez avec les variables de n'importe quel autre thread, il est susceptible de ne pas être thread-safe.

Bien sûr, ce n'est toujours pas très Scala-ish. Vous devriez essayer d'éviter l'état mutable partout où vous le pouvez. Si vous avez du code qui a du mal à refactoriser, les bonnes personnes de Stack Overflow sont toujours prêts à vous aider.

Answer 3

La solution de scala native doit utiliser scala.util.DynamicVariable [T]. .: par exemple

import scala.util._ 

class TL { 
    var x = 0 
} 

object TL extends DynamicVariable[TL](null) { 
    def apply() = value 
    def initialize { value = new TL } 
} 

class Counter(val limit: Int) extends Runnable { 
    def run { 
    TL.initialize 
    for (i <- 1 to limit) { TL().x += 1 } 
    println(TL().x) 
    } 
} 

object Program extends App { 
    val t1 = new Thread(new Counter(1000000000)) 
    val t2 = new Thread(new Counter(2000000000)) 
    t1.start; t2.start; t1.join; t2.join 
} 

En interne, DynamicVariable utilise java.lang.InheritableThreadLocal.