Why is Scala good for concurrency?

Question

Are there any special concurrency operators, or is functional style programming good for concurrency? And why?

Answer 1

At the moment, Scala already supports two major strategies for concurrency - thread-based concurrency (derived from Java) and type-safe Actor-based concurrency (inspired by Erlang). In the nearest future (Scala 2.9), there will be two big additions to that:

• Software Transactional Memory (the basis for concurrency in Clojure, and probably the second most popular concurrency-style in Haskell)
• Parallel Collections (without going into detail, they allow for parallelizing basic collection transformers, like foreach or map across multiple threads).

Actor syntax (concurrency operators) is heavily influenced by Erlang (with some important additions) - with regards to the library you use (standard actors, Akka, Lift, scalaz), there will be different combinations of question and exclamation marks: ! (in the most cases for sending a message one-way), !!, !?, etc.

Besides that, first-class functions make your life way easier even when you work with old Java concurrency frameworks: ExecutorService, Fork-Join Framework, etc.

Above all of that stands immutability that simplifies concurrency a lot, making code more predictable and reliable.

Answer 2

There are a number of language features that make Scala good for concurrency. For example:

• Most of the data structures are immutable and don't require anything special for concurrent access.
• The functional style is a really good way to do highly concurrent operations.
• Scala includes a really handy "actor" framework that helps with concurrent asynchronous operations.

Further reading:

http://www.ibm.com/developerworks/java/library/j-scala02049.html

http://blog.objectmentor.com/articles/2008/08/14/the-seductions-of-scala-part-iii-concurrent-programming

http://akka.io