Scala synchronization best practice

Question

I've started to learn Scala and Akka as the actor model. In an imperative language like C for example i can use several different methods for synchronizing threads on for example a binary tree; a simple semaphore or a mutex, atomic operations, and so on.

Scala however, is a functional object oriented language which can implement an actor model utilizing the Akka library (for example). How should synchronization be implemented in Scala? Let's say that i have i binary tree which my program is suppose to traverse and perform different operations upon. How should i make sure that two different actors isn't, for example, deleting the same node simultaniously?

As asked, the answer is Scala is mostly the same as in Java, you use the built-in synchronized HOF. But I suspect the question you mean to ask is "What are the best practices for achieving thread safety for concurrent / parallel programs?" For that, the story is less simple. Actors and Futures go a very long way and each have their strengths and weaknesses and largely complement each other. — Randall Schulz
– Randall Schulz, Commented Apr 2, 2014 at 14:25
Thank you for your response @RandallSchulz. I am new to Scala so i don't know so much about the language specific terminology. However i know concurrent programming, and you are right. My question is more of the type, how to achieve thread safety. — Anton Gildebrand
– Anton Gildebrand, Commented Apr 3, 2014 at 6:32

jjmerelo · Accepted Answer · 2016-10-16 17:12:46Z

9

If you want to do synchonized access to data structures, just use the synchronized method of AnyRef to synchronize a block. For example:

object Test {
  private val myMap = collection.mutable.Map.empty[Int, Int]
  def set(key: Int, value: Int): Unit = synchronized { myMap(key) = value }
  def get(key: Int): Option[Int] = synchronized { myMap.get(key) }
}

However, the point of using actors is to avoid threads blocking one another, which would hurt scalability. The Actor way of managing mutable state is for state to be private to Actor instances, and only updated or accessed in response to messages. This is a more complex design, something like:

// define case classes Get, Set, Value here.
class MapHolderActor extends Actor {
  private val myMap = collection.mutable.Map.empty[Int, Int] 
  def receive {
    case Get(key) => sender ! Value(myMap.get(key))
    case Set(key, value) => myMap(key) = value
  }
}

edited Oct 16, 2016 at 17:12

jjmerelo

23.6k8 gold badges44 silver badges98 bronze badges

answered Apr 2, 2014 at 14:18

Richard Close

1,90511 silver badges17 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Richard Close Over a year ago

om-nom-nom got in while I was typing! My answer corresponds to om's points 2 and 1, respectively.

om-nom-nom · Accepted Answer · 2014-04-02 14:31:49Z

5

On a high level you can use Actor as a mutex: it processes all incoming messages one by one.
On the lower levels (but not at the actor level), nothing stops you from using plain old java concurrency primitives
Use immutable data structures, as @Tanmay proposed, so there will be no in-place modification, thus no data races
There are transactors (although deprecated in the very recent akka versions)

edited Apr 2, 2014 at 14:31

answered Apr 2, 2014 at 14:16

om-nom-nom

62.9k13 gold badges186 silver badges231 bronze badges

Collectives™ on Stack Overflow

Scala synchronization best practice

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related