Functional way to implement a stream safe shared counter

Question

I am relatively new to Scala and functional programming, and I like the idea that using immutable objects can avoid many of the problems associated with threads. I'm still haunted, and this is a classic example used to teach thread safety - a common counter.

I was wondering if it is possible to implement a thread-safe counter (request counter in this example), use immutable objects and functional concepts, and completely eliminate synchronization.

So, for reference, here are first the classic mutable counter versions (excuse me for the public member variable, just for brevity examples)

Mutable, Non thread safe version:

public class Servlet extends HttpServlet { public int requestCount = 0; @Override public void service(ServletRequest req, ServletResponse res) throws ... { requestCount++; //thread unsafe super.service(req, res); } } 

Mutable, classic version with streaming security: (or I hope ...)

 public class Servlet extends HttpServlet { public volatile int requestCount = 0; @Override public void service(ServletRequest req, ServletResponse res) throws ... { synchronized (this) { requestCount++; } super.service(req, res); } } 

I was wondering if there is a way to use immutable objects and variable variables to ensure thread safety without synchronization.

So here is my naive attempt. The idea is to have an immutable object for the counter and simply replace the reference to it using a mutable variable. Feels fishy, ​​but worth a shot.

Owner:

 public class Incrementer { private final int value; public Incrementer(final int oldValue) { this.value = oldValue + 1; } public Incrementer() { this.value = 0; } public int getValue() { return value; } } 

Modified Servlet:

 public class Servlet extends HttpServlet { public volatile Incrementer incrementer = new Incrementer(); @Override public void service(ServletRequest req, ServletResponse res) throws ... { incrementer = new Incrementer(incrementer.getValue()); super.service(req, res); } } 

I have a strong feeling that this is also not thread safe, since I am reading with an increment and can get an obsolete value (for example, if the link has already been replaced by another thread). If this is really not thread safe, then I wonder if there is any “functional” way to handle such a counter script without locking / synchronizing.

So my question (s)

• How safe is this thread?
• If so, why?
• If not, is there any way to implement such a counter without synchronization?

Although the above sample code is provided in Java, answers in Scala are of course also welcome.

Answer 1

How safe is this thread?

No, if you have not already created an immutable object in a synchronized block, this is not thread safe. There are chances of creating a damaged immutable object in a thread race.

And to achieve the same functionality, you can use AtomicInteger , which avoids explicit synchronization.

 public class Servlet extends HttpServlet { public AtomicInteger incrementer = new AtomicInteger (0); @Override public void service(ServletRequest req, ServletResponse res) throws ... { int newValue = incrementer.incrementAndGet(); super.service(req, res); } } 

Answer 2

Protecting threads from immutable looks much more.

 val x = AtomicReference(Vector("salmon", "cod")) // Thread 1 val y = x.get println(y(y.length-1)) // Thread 2 x.getAndSet(x.get.tail) 

If you were working with volatility, you would be very tempted if Thread 2 changed the modified list, which could make Thread 1 an unsuccessful index. Or you will have to copy data, which can be very expensive if you do not have collections designed for reuse as much as possible (and if the vector was longer). Or, you will have to synchronize large blocks in both threads instead of just atomizing and / or getting your data settings.

You still have to synchronize, and you may have to deal with outdated copies of the data. But you don’t need to keep track of who copies the data structure and synchronizes everyone as crazy, because this data can change from under you and exclude exceptions throughout the place.