Venkat Subramaniam - Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors

To Mom and Dad, for teaching the values of integrity, honesty, and diligence.

• STM in Clojure, Groovy,
  Java, JRuby, and Scala

Speed. Aside from caffeine, nothing quickens the pulse of a programmer as much as the blazingly fast execution of a piece of code.How can we fulfill the need for computational speed? Moores law takes us some of the way, but multicore is the real future. To take full advantage of multicore, we need to program with concurrency in mind.

In a concurrent program, two or more actions take place simultaneously. A concurrent program may download multiple files while performing computations and updating the database. We often write concurrent programs using threads in Java. Multithreading on the Java Virtual Machine (JVM) has been around from the beginning, but how we program concurrency is still evolving, as well learn in this book.

The hard part is reaping the benefits of concurrency without being burned. Starting threads is easy, but their execution sequence is nondeterministic. Were soon drawn into a battle to coordinate threads and ensure theyre handling data consistently.

To get from point A to point B quickly, we have several options, based on how critical the travel time is, the availability of transport, the budget, and so on. We can walk, take the bus, drive that pimped-up convertible, take a bullet train, or fly on a jet. In writing Java for speed, weve also got choices.

There are three prominent options for concurrency on the JVM:

• What I call the synchronize and suffer model

• The Software-Transactional Memory model

• The actor-based concurrency model

I call the familiar Java Development Kit (JDK) synchronization model synchronize and suffer because the results are unpredictable if we forget to synchronize shared mutable state or synchronize it at the wrong level. If were lucky, we catch the problems during development; if we miss, it can come out in odd and unfortunate ways during production. We get no compilation errors, no warning, and simply no sign of trouble with that ill-fated code.

Programs that fail to synchronize access to shared mutable state are broken, but the Java compiler wont tell us that. Programming with mutability in pure Java is like working with the mother-in-law whos just waiting for you to fail. Im sure youve felt the pain.

There are three ways to avoid problems when writing concurrent programs:

• Synchronize properly.

• Dont share state.

• Dont mutate state.

If we use the modern JDK concurrency API, well have to put in significant effort to synchronize properly. STM makes synchronization implicit and greatly reduces the chances of errors. The actor-based model, on the other hand, helps us avoid shared state. Avoiding mutable state is the secret weapon to winning concurrency battles.

In this book, well take an example-driven approach to learn the three models and how to exploit concurrency with them.

Ive written this book for experienced Java programmers who are interested in learning how to manage and make use of concurrency on the JVM, using languages such as Java, Clojure, Groovy, JRuby, and Scala.

If youre new to Java, this book will not help you learn the basics of Java. There are several good books that teach the fundamentals of Java programming, and you should make use of them.

If you have fairly good programming experience on the JVM but find yourself needing material that will help further your practical understanding of programming concurrency, this book is for you.

If youre interested only in the solutions directly provided in Java and the JDKJava threading and the concurrency libraryI refer you to two very good books already on the market that focus on that: Brian Goetzs Java Concurrency in Practice [Goe06] and Doug Leas Concurrent Programming in Java [Lea00]. Those two books provide a wealth of information on the Java Memory Model and how to ensure thread safety and consistency.

My focus in this book is to help you use, but also move beyond, the solutions provided directly in the JDK to solve some practical concurrency problems. You will learn about some third-party Java libraries that help you work easily with isolated mutability. You will also learn to use libraries that reduce complexity and error by eliminating explicit locks.