Does using only immutable data types make a Java program thread safe?

Answer 1

Thread safety is about protecting shared data and immutable objects are protected as they are read only. Well apart from when you create them but creating a object is thread safe.

It's worth saying that designing a large application that ONLY uses immutable objects to achieve thread safety would be difficult.

It's a complicated subject and I would recommend you reading Java Concurrency in Practice which is a very good place to start.

Answer 2

Ok ok, it is true, but i still insist that in Java it is so complex that you can treat it as "no".

Immutable just mean that if you want to modify you must create new instance. All operations on thread global variables are not thread safe.

Let me explain. Java is imperative language so i would really like to see how you create application that consists of only immutable types. What about counters for example? How to you plan to increment something immutable?

So you can't make Java app with only immutable types, you will stop at some time and use some mutable. And here you are not thread safe.

It is possible to live with only immutable types if you are using functional language, like Haskell, but Java is not that functional.

Answer 3

It is true. The problem is that it's a pretty serious limitation to place on your application to only use immutable data types. You can't have any persistent objects with state which exist across threads.

I don't understand why you'd want to do it, but that doesn't make it any less true.

Details and example: http://www.javapractices.com/topic/TopicAction.do?Id=29

Answer 4

If every single variable is immutable (never changed once assigned) you would indeed have a trivially thread-safe program.

Functional programming environments takes advantage of this.

However, it is pretty difficult to do pure functional programming in a language not designed for it from the ground up.

A trivial example of something you can't do in a pure functional program is use a loop, as you can't increment a counter. You have to use recursive functions instead to achieve the same effect.

If you are just straying into the world of thread safety and concurrency, I'd heartily recommend the book Java Concurrency in Practice, by Goetz. It is written for Java, but actually the issues it talks about are relevant in other languages too, even if the solutions to those issues may be different.

Answer 5

Immutability allows for safety against certain things that can go wrong with multi-threaded cases. Specifically, it means that the properties of an object visible to one thread cannot be changed by another thread while that first thread is using it (since nothing can change it, then clearly another thread can't).

Of course, this only works as far as that object goes. If a mutable reference to the object is also shared, then some cases of cross-thread bugs can happen by something putting a new object there (but not all, since it may not matter if a thread works on an object that has already been replaced, but then again that may be crucial).

In all, immutability should be considered one of the ways that you can ensure thread-safety, but neither the sole way nor necessarily sufficient in itself.

Answer 6

Although immutable objects are a help with thread safety, you may find "local variables" and "synchronize" more practical for real world progamming.