Does Immutability Really Mean Thread Safety?

DZone 's Guide to

Does Immutability Really Mean Thread Safety?

I am going to try to define immutability and its relation to thread safety.

· Java Zone ·
Free Resource

I have often read articles saying "If an object is immutable, it is thread safe."  But I have never found an article that convinces me that 'immutable' means thread safety. Even the book by Brian Goetz Java Concurrency in Practice with its chapter on immutability did not fully satisfiy me. In this book we can read word for word, in a frame : Immutable objects are always thread-safe. I think this sentence deserves more explanation. So I am going to try to define immutability and its relation to thread safety.



My definition is "An immutable object is an object that will not change its state after its construction". I am deliberately vague, since no one really agrees on the exact definition.

Thread safety

You can find a lot of different definitions of "thread safe" on internet. It's actually very tricky to define it. I would say that thread safe code has an expected behavior in multi-thread environment. I'll let you define "expected behavior"...

The String example

Lets have a look at the code of String (actually just a part of the code...):

public class String {
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    public String(char[] value) {
        this.value = Arrays.copyOf(value, value.length);

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            hash = h;
        return h;

String is considered immutable. Looking at its implementation, we can deduce one thing: an immutable string can change its internal state (in this case, the hashcode which is lazy loaded) as long as it is not externally visible.Now I am going to rewrite the hashcode method in a non-thread safe way:

    public int hashCode() {
        if (hash == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                hash = 31 * hash + val[i];
        return hash;

As you can see, I have removed the local variable h and I have instead affected the variable hash directly. This implementation is NOT thread safe! If several threads call hashcode at the same time, the returned value could be different for each thread. The question is, 'is this class immutable?' Since two different threads can see a different hashcode, in an external point of view we have a change of state and so it is not immutable.We can so conclude that String is immutable because it is thread safe and not the opposite. So... What's the point of saying "Use an immutable object, it is thread-safe! But take care, you have to make your immutable object thread-safe!"?

The ImmutableSimpleDateFormat example

Below, I have written a class similar to SimpleDateFormat.

public class VerySimpleDateFormat {

    private final DateFormat formatter = SimpleDateFormat.getDateInstance(SimpleDateFormat.SHORT);

    public String format(Date d){
        return formatter.format(d);

This code is not thread safe because SimpleDateFormat.format is not.Is this object immutable? Good question! We have done our best to make all fields not modifiable, we don't use any setter or any methods that let us suggest that the state of the object will change. Actually, internally SimpleDateFormat changes its state, and that's what makes it non-thread safe. Since something changed in the object graph, I would say that it's not immutable, even if it looks like it...

The problem is not even that SimpleDateFormat changes its internal state, the problem is that it does so in a non-thread safe way. In conclusion, it is not that easy to make an immutable class. The final keyword is not enough. You have to make sure that the object fields of your object don't change their state, which is sometimes impossible.

Immutable objects can have non thread-safe methods (No magics!)

Let's have a look at the following code.

public class HelloAppender {

    private final String greeting;

    public HelloAppender(String name) {
        this.greeting = "hello " + name + "!\n";

    public void appendTo(Appendable app) throws IOException {

The class HelloAppender is definitely immutable. The method appendTo accepts an Appendable. Since an Appendable has no guarantee to be thread-safe (eg. StringBuilder), appending to this Appendable will cause problems in a multi-thread environment.


Making objects immutable is definitely a good practice in some cases and it helps a lot to make thread-safe code. But it bothers me when I read everywhere Immutable objects are thread safe, displayed as an axiom. I get the point but I think it is always good to think a bit about that in order to understand what causes non-thread safe code.Since I am not fully satisfied by the sentence Immutable objects are thread safe, I finish this article with my own sentence:  Immutable objects ease concurrency programming.

java, tutorial

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}