Just learned one interesting aspect of immutables: Besides the fact that they help you to provide a lot of ugly threading problems, they potentially speed your your code by itself. The trick is that once you prevent the creation of two identical object instances (e. g. by using builders and caches) you can be sure that two references always point to distinct objects. As the objects are immutable, this is an invariant. Hence, you can reduce the equals() and hashCode() methods to fixed implementations: There is no more need to actually compare any state, but it is enough to compare the reference itself. This certainly speeds up the code, even in non-parallel situations. Also, you spare memory, as you will never have any copies, but only singletons. As a side effect, less GC pressure exists, which also will result in faster Overall execution.
Cool, this really is the tip of my day. Good that I had time to attend “parallel//2016” conference. 🙂