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

Sé que los objetos inmutables siempre tienen el mismo estado, el estado en el que realmente se crean. Sus invariantes las establece el constructor y, dado que su estado no cambia después de la construcción, esas invariantes siempre se mantienen y es por eso que es seguro publicarlas en un entorno de subprocesos múltiples. Todo esto está bien, pero dado que vivimos en un mundo dinámico, donde el estado del programa cambia continuamente, ¿qué beneficios nos brindan tales objetos si construimos el estado de nuestro programa a través de objetos inmutables?

preguntado el 02 de julio de 12 a las 13:07

Aquí hay otra publicación que puede tener la respuesta a su pregunta: stackoverflow.com/questions/214714/mutable-vs-immutable-objects -

Los objetos inmutables son como hechos. Los hechos no cambian, pero siempre puedes 'hacer' otros nuevos. -

4 Respuestas

"¿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.

Respondido 02 Jul 12, 14:07

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.

Respondido 02 Jul 12, 14:07

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?

contestado el 23 de mayo de 17 a las 13:05

Los objetos inmutables no solo tienen atomicidad de falla, sino que dicha atomicidad a menudo se extiende a los poseedores mutables de dichos objetos. Si yo Fnord es una clase inmutable, y un objeto tiene un campo foo de ese tipo de clase, una declaración como foo = foo.WithWizzleAndWozzle(5,3); [que debería cambiar efectivamente el valor de foo.Wizzle a 5 y foo.Wozzle a 3] cambiará ambos valores o ninguno. No hay manera de que pueda cambiar uno sin cambiar el otro. - Super gato

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 pronto quedará obsoleto, tal vez, pero mantener su valor durante el método de llamada y permanecer consistente.

Respondido 02 Jul 12, 20:07

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.