Cache objects as Immutable classes

Question

I am asking very generic question and the answer can vary from requirement to requirement, but for "general" or "rule of thumb", can we say the following is a good design rule:

The classes to be cached (static/reference data) should be designed as immutable, with exceptions reasoned.

What could be design/performance issues with the above statement, if this is not true?

Answer 1

@JohnB has a good answer about the underlying data.

If, however, the question is referring to the immutability of the cached classes themselves (which are holding the data in the cache), then the answer is that mutable classes can cause thread-safety issues if the instances of the classes are referenced by multiple threads (as can often happen with data shared via a cache). Additionally, "accidental" modification of the data may occur, where a shared instance is unintentionally modified (because the modifying code did not know that the data was shared).

Answer 2

This is because of what a cache does, which is hold data rather than retrieving it from the data source again. For example, you query the database for a value then put it in a memory-based cache so you don't have to query the DB again. However, if the value in the DB can change then the value in the cache will be out of date and your application will be using the wrong data.

Therefore, caching is best if the data cannot change during the live of the application. If the data can change, then a strategy must be developed to regularly check to see if the data has changed.

Answer 3

What jtahlborn is explaining in other words : an immutable class will provide methods to obtain "static" data.

If your class is immutable, you will NOT have setters except the parameters in the constructor.

Take care making this : immutable classes are not made to be used only once, it would result in a performance loss, since copies of inner attributes have to be done each time you access the get... methods.

Example :

class MyImmutableThing {

  private final String myProperty;

  MyImmutableThing(String myProperty) {
    this.myProperty = myProperty;
  }

  String obtainMyProperty() {
    return myProperty;
  }

    // note there is no mean to modify the myProperty value : the original value remains ;)
    // That's it !
}