Scala- How do I determine if an object is thread-safe? - scala

Question

object GetDetails{
def apply(outStream: java.io.Writer, someObject: SomeClass){
outStream.write(someObject.detail1) //detail1 is string
outStream.write(someObject.detail2) //detail2 is also string
outStream.flush()
}
}
If this implementation is not thread-safe how do I make it thread-safe?
This function is going to be called simultaneously with different inputs.

Answer 1

One thing to think about is how the "state" of your application might change when two different threads call the same function, or interact with the same object. In this case, your "state" might be "what's been written to outStream".
Consider the following scenario:
Thread 1 Thread 2
-------------------- -------------------------------
GetDetails(outStream, object1)
GetDetails(outStream, object2)
outStream.write(object1.detail1)
outStream.write(object2.detail1)
outStream.write(object1.detail2)
outStream.write(object2.detail2)
outStream.flush()
outStream.flush()
Two separate threads both call GetDetails, sharing the same outStream. This is a potential concurrency problem, as the data that gets written to outStream is not guaranteed to be in any particular order. You might get [object1.detail1, object2.detail1, object1.detail2, object2.detail2], or [object2.detail1, object1.detail1, object1.detail2, object2.detail2], and so on.
GetDetails.apply does not change any of GetDetails's state, but it does change the state of the Writer that you pass; in order to ensure thread-safety you must take efforts to avoid using the same Writer at the same time (i.e. the scenario above).
As a counter-point, here's a pretty thread-unsafe method:
object NotThreadSafe {
// mutable state
private var currentPrefix = ""
def countUp(prefix: String) = {
// red flag: changing mutable state, then referring to it
currentPrefix = prefix
for(i <- 1 to 5) println(s"$currentPrefix $i")
}
}
If thread 1 calls NotThreadSafe.countUp("hello") and thread 2 calls NotThreadSafe.countUp("goodbye"), the output will depend on which currentPrefix = prefix happens last.
You could end up with
hello 1
hello 2
goodbye 3 // should have been hello 3, but currentPrefix got changed
goodbye 1
goodbye 4 // should have been hello 4
goodbye 5 // should have been hello 5
goodbye 2
goodbye 3
goodbye 4
goodbye 5
or one of many other permutations.
This is one reason why Scala tends to prefer "immutability" and "statelessness", because those are tools that simply don't need to worry about this kind of issue.
If you do find yourself forced to deal with mutable state, often the simplest way to ensure thread safety is to ensure your method can only be called once at a time, i.e. by using synchronized. At a finer-grained level, you want to ensure that a specific sequence of steps is not interleaved with another copy of that sequence on another thread (e.g. the GetDetails scenario I described at the beginning).
You could also look into semaphores but that's beyond the scope of this answer.