Utilidad de los objetos inmutables cuando el estado de un programa cambia constantemente

"¿Qué beneficios nos dan tales objetos?" Ya respondiste eso.

Con respecto a la parte "dinámica" de su pregunta, si necesita "cambiar" un objeto inmutable, puede crear uno nuevo a partir del anterior:

Immutable oldObj = new Immutable(...);
Immutable newObj = new Immutable(oldObj.property1, "a new value for property 2");

Si descubre que sigue haciendo eso repetidamente, entonces tal vez necesite hacer que el objeto sea mutable y agregar las características relevantes de seguridad de la banda de rodadura que se necesitan para poder usar ese objeto en un entorno concurrente.

Los objetos inmutables le permiten comunicar claramente los cambios de estado a diferentes subprocesos.

Es una buena práctica usar objetos inmutables para representar mensajes intercambiados entre hilos. Una vez que se envía dicho mensaje, su carga útil no se puede modificar, lo que evita muchos errores relacionados con la concurrencia. Si un hilo necesita comunicar algunos cambios adicionales, simplemente envía los siguientes mensajes.

Immutable objects son muy útiles cuando necesita un objeto estático cuyo estado nunca cambia. La mayor ventaja es la inmutabilidad, la semántica del objeto y los punteros inteligentes hacen que la propiedad del objeto sea un punto discutible. Implícitamente, esto también significa un comportamiento determinista en presencia de concurrencia.

Java ya ha definido algunas clases inmutables como String Integer.

Otro beneficio es que siempre tienen "atomicidad de falla" (un término usado por Joshua Bloch): si un objeto inmutable genera una excepción, nunca se deja en un estado indeseable o indeterminado.

Digamos que si tiene un caché global de objetos estáticos como códigos de países, aquí puede aplicar Immutability.

¿Por qué necesitamos una clase inmutable?

Los objetos inmutables son realmente útiles en casos como este, con un objeto String:

public class A  {
    private volatile String  currentName = "The First Name";

    public String getCurrentName()  {
        // Fast:  no synching or blocking!  Can be called billions of times by
        // billions of threads with no trouble.
        // (Does need to be read from memory always because it's volatile.)
        return currentName;
    }
    public whatever someMethod()  {
        ... code ...
        // Simple assignment in this case.  Could involve synchronization
        // and lots of calculations, but it's called a lot less than
        // getCurrentName().
        currentName = newName;
        ... code ...
    }
}
public class B  {
        ... in some method ...
        A  objA = something;
        // Gets "name" fast despite a billion other threads doing the same thing.
        String  name = objA.getCurrentName();
        // From this point on, String referenced by "name" won't change
        // regardless of how many times A.currentName changes.
        ... code with frequent references to objA
}

Esto permite que los datos complejos (o incluso datos simples, en este caso) que deben ser consistentes (si no precisamente actualizados) se actualicen y entreguen a cualquier persona que los desee de manera muy rápida y segura. Los datos entregados seguirá pronto quedará obsoleto, tal vez, pero seguirá mantener su valor durante el método de llamada y permanecer consistente.