Is mutable variable in a thread thread-safe?

Question

I want to use some mutable vars defined in a thread MyT which extends Java's Thread in application and the usage will be as Thread.currentThread.asInstanceof[MyT] to reference and update mutable vars in it.

Will this be thread-safe?

update

I wrote some application using scala without any consideration of multi-thread issues and with the so-called worst practice of using mutable variables in object (because it is so easy to use for beginners!).

But now somehow the project extends to a web application, that I have to deal with multi-threading issues.

I dont have time to rewrite the code again, to refactor every mutable vars in object as arguments around (probably one solution of not using global object mutable vars), so I am thinking about moving the mutable vars in object to a thread class that extends Thread class, and refactor the code to use Thread.currentThread and then cast the instance to my extends thread type, and then to reference/update to the mutable vars which are originally global mutable vars.

So here comes my original question.

Answer 1

Use ThreadLocal for this purpose : http://java.dzone.com/articles/java-thread-local-%E2%80%93-how-use

Answer 2

If you only interact with the mutable variables from within the thread itself (the Thread.currentThread.asInstanceof[MyT] use case you mentioned), then it is thread safe (and usually faster than ThreadLocal).

If you interact with the variables from any other thread, then it is likely to not be thread safe.

Of course, it's still not very Scala-ish. You should try to avoid mutable state wherever you can. If you've got some code that looks hard to refactor, the good people of Stack Overflow are always keen to help.

Answer 3

The native scala solution is to use scala.util.DynamicVariable[T]. E.g.:

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
}

Internally, DynamicVariable uses java.lang.InheritableThreadLocal.