{
  "version": "2",
  "formats": {
    "markdown": {
      "content": "## Page 1\n\nUnidad 1\nProgramación concurrente\n\nTema 1 Conceptos\n\n&lt;page_number&gt;1&lt;/page_number&gt;\n\n---\n\n\n## Page 2\n\n# Contenidos\n\n*   Introducción\n*   Estructuras básicas de soporte a la concurrencia en Java\n    *   Threads, ciclo de vida, prioridades, interrupciones, estados\n    *   Ejecutores\n    *   Ejemplo Partículas en movimiento\n*   Objetos y concurrencia\n    *   Concurrencia\n    *   Estructuras para la ejecución concurrente\n    *   Concurrencia y programación OO\n    *   Transformaciones y modelos de objetos\n*   Imposiciones de diseño\n*   Bibliografía\n\n&lt;page_number&gt;2&lt;/page_number&gt;\n\n---\n\n\n## Page 3\n\n# Introducción\n\n*   **Un programa concurrente**\n    Es un programa que hace más de una cosa a la vez\n*   **Una definición de proceso o hilos**\n    Secuencia de llamadas que se ejecuta independientemente de otras, mientras que posiblemente al mismo tiempo, comparta recursos del sistema tales como archivos, además de acceder a otros objetos construidos en el mismo programa\n*   **Ejecución en paralelo de procesos o hilos**\n    *   Si la arquitectura hardware realmente lo permite se mejorarán los tiempos.\n    *   Problemas cuando las “partes” (proceso o hilos) interfieren entre sí.\n\n&lt;page_number&gt;3&lt;/page_number&gt;\n\n---\n\n\n## Page 4\n\n# Introducción\n\n*   Diagrama de proceso e hilos\n*   N hilos ejecutándose dentro del contexto del proceso\n\n<mermaid>\ngraph TD\n    subgraph Proceso\n        A[Datos]\n        B[Código]\n        C[Descriptor]\n    end\n\n    subgraph Thread 1\n        D[Pila]\n        E[Descriptor]\n    end\n\n    subgraph Thread 2\n        F[Pila]\n        G[Descriptor]\n    end\n\n    subgraph Thread 3\n        H[Pila]\n        I[Descriptor]\n    end\n\n    J[...]\n</mermaid>\n\nEjecución concurrente de hilos.\nDatos (objetos) **compartidos**.\nCada hilo mantiene su propia pila.\n\n&lt;page_number&gt;4&lt;/page_number&gt;\n\n---\n\n\n## Page 5\n\n# Estructuras básicas de soporte a la concurrencia en Java\n\n*   A un lenguaje secuencial se añade el **soporte de hebras**:\n    *   “procesos ligeros”, hilos o threads\n*   No crea procesos paralelos (aunque también se puede) sino tareas dentro del mismo proceso\n    *   Menor costo que crear y destruir procesos.\n    *   Todo proceso tiene como mínimo uno, el hilo principal.\n*   Transparente al sistema operativo con planificación no determinista.\n*   Problemas asociados a la compartición de memoria y ficheros.\n*   A partir de Java 5 con soporte adicional de bibliotecas.\n\n&lt;page_number&gt;5&lt;/page_number&gt;\n\n---\n\n\n## Page 6\n\nEstructuras básicas de soporte a la concurrencia en Java: Ciclo de vida de un hilo\n\n*   Diagrama de estados y transición en los hilos\n\n<mermaid>\ngraph LR\n    subgraph \" \"\n        A[creado] -->|start| B{ejecutable}\n        B -->|El S.O. despacha la tarea| C{en ejecución}\n        C -->|retorno fallo| D[terminado]\n        C -->|desbloqueado| B\n        C -->|bloqueo| E[bloqueado]\n        C -->|synchronized Petición E/S| E\n        C -->|wait sleep| F{espera}\n        C -->|wait| F\n        C -->|intervalo expira notify notifyAll| B\n        B -->|Expira el quantum yield| C\n        B -->|notify notifyAll| F\n        F -->|wait| B\n        F -->|wait| G{espera sincronizada}\n        G -->|synchronized Petición E/S| E\n        E -->|interrupt Finaliza petición E/S| C\n    end\n</mermaid>\n\n&lt;page_number&gt;6&lt;/page_number&gt;\n\n---\n\n\n## Page 7\n\n# Estructuras básicas de soporte a la concurrencia en Java: Threads\n\n*   Opciones básicas de implementación de hilos:\n    *   Extender de `java.lang.Thread`\n        *   Redefinir el método `run()`\n        *   Lanzar el hilo con el método `start`\n    *   Implementar la interface `Runnable`\n        *   Redefinir el método `run()`\n        *   Pasar como argumento un objeto que implementa dicha interfaz al crear un hilo (`new Thread`)\n            *   **Solución preferente**\n                *   Tip: no hay herencia múltiple de clases en Java (pero sí de interfaces)\n        *   Ejemplo (con `Runnable`):\n            *   se lanzan 10 hilos en paralelo cada uno con un identificador. Se muestra un mensaje 1000 veces y se finaliza.\n\n```java\npublic class HilosBásicos {\n    public static void main(String[] args) {\n        for (int i = 0; i < 10; i++) {\n            Thread t = new Thread(new Hilo(i));\n            t.start(); // lanzar hilo\n        }\n        System.out.println(\"Esperando al fin...\");\n    }\n}\n\npublic class Hilo implements Runnable {\n    int id;\n    int contador = 1000;\n\n    public Hilo(int id) {\n        this.id = id;\n    }\n\n    public void run() {\n        for (; contador > 0; contador--) {\n            System.out.println(\"Soy el hilo: \" + id);\n            Thread.yield(); // ceder paso, no determinista\n        }\n    }\n}\n```\n\n&lt;page_number&gt;7&lt;/page_number&gt;\n\n---\n\n\n## Page 8\n\n# Estructuras básicas de soporte a la concurrencia en Java: Prioridades\n\n*   Prioridades de los hilos para su planificación:\n    *   MIN_PRIORITY a MAX_PRIORITY = [0..10]\n    *   Valor por defecto NORM_PRIORITY = 5\n    *   Método setPriority para modificar la prioridad\n    *   Cada hilo hereda la prioridad del hilo que lo crea\n*   No garantizan un orden de ejecución\n*   Comportamiento variable en función de la plataforma\n    *   La programación SÍ es independiente de la plataforma\n    *   El comportamiento del programa NO\n        *   Tip: editar, compilar y ejecutar los ejemplos varias veces y en distintas plataformas para observar esto\n\n&lt;page_number&gt;8&lt;/page_number&gt;\n\n---\n\n\n## Page 9\n\n# Estructuras básicas de soporte a la concurrencia en Java: Dormir hilos\n\n*   Los hilos se pueden “dormir” o parar por un determinado tiempo\n    *   Suspende el hilo actual.\n*   Ejemplo:\n    *   Dormir tareas usando TimeUnit\n\n```java\nimport java.util.concurrent.*; // para importar TimeUnit\n\npublic class HilosBásicos {\n    public static void main(String[] args) {\n        for (int i = 0; i < 10; i++) {\n            Thread t = new Thread(new Hilo(i));\n            t.start();\n        }\n        System.out.println(\"Esperando al fin...\");\n    }\n}\n\nclass Hilo implements Runnable {\n    int id;\n    int contador = 1000;\n\n    public Hilo(int id) {\n        this.id = id;\n    }\n\n    public void run() {\n        try {\n            for (; contador > 0; contador--) {\n                System.out.println(\"Soy el hilo: \" + id);\n                // Dormir al hilo 1 segundo\n                // Thread.sleep(1000); Estilo previo a Java 5\n                TimeUnit.MILLISECONDS.sleep(1000); // solución actual\n            }\n        } catch (InterruptedException ex) {\n            System.err.println(\"Interrumpido\");\n        }\n    }\n}\n\n---\n\n\n## Page 10\n\n# Estructuras básicas de soporte a la concurrencia en Java: Esperar a hilos\n\n*   El método de Thread.join() permite un hilo esperar a la finalización de otro.\n    *   t.join();\n*   Suspende el hilo actual, si t es un objeto Thread cuyo hilo se está ejecutando actualmente\n*   Ejemplo:\n    *   El hilo principal espera a escribir el mensaje hasta que no haya terminado t\n\n```java\npublic class HilosBásicos {\n    public static void main(String[] args) throws InterruptedException {\n        Thread t = new Thread(new Hilo(1));\n        t.start();\n        t.join();\n        System.out.println(\"Programa terminado...\");\n    }\n}\n```\n&lt;page_number&gt;10&lt;/page_number&gt;\n\n---\n\n\n## Page 11\n\n# Estructuras básicas de soporte a la concurrencia en Java : Interrupciones\n\n*   Una interrupción es una indicación a un hilo que debería dejar de hacer lo que está haciendo y hacer otra cosa\n    *   Un hilo envía una interrupción invocando a Thread.interrupt() del hilo que se quiere interrumpir\n*   Es responsabilidad del programador decidir exactamente cómo un hilo responde a una interrupción\n*   ¿Cómo soporta un hilo las interrupciones?\n    *   Depende de lo que esté haciendo\n        *   Si está en métodos que lanzan InterruptedException\n        *   Si no consultar Thread.interrupted()\n\n&lt;page_number&gt;11&lt;/page_number&gt;\n\n---\n\n\n## Page 12\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejecutores\n\n*   A partir de Java 5 la gestión de hilos se puede delegar\n*   Los ejecutores crean y administran la ejecución de un objeto Runnable\n*   Ventajas\n    *   Reutilizar hilos existentes para eliminar la sobre carga de creación\n    *   Optimizar el rendimiento definiendo un número de hilos adecuado al entorno de ejecución en explotación\n*   Existen una jerarquía de tres niveles de interfaces\n    *   Cada uno incrementa la funcionalidad del anterior\n        *   Executor.execute() lanza un hilo con un objeto Runnable\n\n```java\nThread t = new Thread(...);\nt.start();\n//Método alternativo basado en ejecutores\nExecutor exec = Executors.newSingleThreadExecutor();\nexec.execute(t);\n```\n\n&lt;page_number&gt;12&lt;/page_number&gt;\n\n---\n\n\n## Page 13\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejecutores\n\n*   Existen una jerarquía de tres niveles de interfaces\n    *   ExecutorService: añade características que ayudan a administrar el ciclo de vida, tanto de las tareas individuales y del propio ejecutor\n        ```java\nExecutorService exec = Executors.newSingleThreadExecutor();\nexec.execute(t);\n//Terminación del servicio\nexec.shutdown();\n```\n*   ScheduledExecutorService: permite planificar con un cierto retardo (delay) (método schedule)\n    *   Proporciona métodos adicionales\n        *   ScheduleAtFixedRate, scheduleWithFixedDelay\n        ```java\nScheduledExecutorService exec =\nExecutors.newScheduledThreadPool(1);\n//Planificar una tarea t que se repite cada 5 segundos\nexec.scheduleAtFixedRate(t, 0, 5, TimeUnit.SECONDS);\nexec.execute(t);\n\n---\n\n\n## Page 14\n\n# Estructuras básicas de soporte a la concurrencia en Java: Depósito de hilos\n\n*   Minimizando el coste de creación de hilos\n    *   Aunque son menos costosos que los proceso siempre acarrea un coste adicional\n*   Consisten en working threads independientes de los objetos Runnable o Callable (tareas)\n    *   newFixedThreadPool: con un depósito fijo de hilos\n    *   newCachedThreadPool: con un deposito dinámico de hilos. Aconsejable con muchas tareas de corta vida.\n    *   newSingleThreadExecutor: ejecuta una tarea como máximo a la vez\n\n&lt;page_number&gt;14&lt;/page_number&gt;\n\n---\n\n\n## Page 15\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejecutores y depósitos\n\n```mermaid\nclassDiagram\n    class \"Fabrica\" {\n        <<java.util.concurrent::Executors>>\n        newFixedThreadPool(int nThreads)\n        newCachedThreadPool()\n        newScheduledThreadPool(int corePoolSize)\n        ...\n        Responsabilidad\n        -- Crear distintos ejecutores\n    }\n    class java.util.concurrent.Executor {\n        crea\n        void execute(Runnable command)\n    }\n    class java.util.concurrent.ExecutorService {\n        crea\n        Future<?> submit(Runnable task)\n        ...\n        void shutdown()\n    }\n    class java.util.concurrent.ScheduledExecutorService {\n        crea\n        scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)\n        schedule(Runnable command, long delay, TimeUnit unit)\n    }\n```\n\n&lt;page_number&gt;15&lt;/page_number&gt;\n\n---\n\n\n## Page 16\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejecutor y depositos\n\n*   Ejemplo de uso:\n    ExecutorService Executors\n\n```java\nimport java.util.concurrent.*;\n\npublic class HilosEjecutores {\n\n    public static void main(String[] args) {\n        ExecutorService exec = Executors.newCachedThreadPool();\n\n        //ExecutorService exec = Executors.newFixedThreadPool(10);\n        //ExecutorService exec =\n        Executors.newSingleThreadExecutor();\n        for (int i = 0; i < 10; i++) {\n            exec.execute(new HiloB(i));\n        }\n        exec.shutdown();\n        System.out.println(\"Esperando al fin...\");\n    }\n\n}\n\nclass HiloB implements Runnable {\n    int id;\n    int contador = 1000;\n    public HiloB(int id) {\n        this.id = id;\n    }\n\n    public void run() {\n        for (; contador > 0; contador--) {\n            System.out.println(\"Soy el hilo: \" + id);\n            Thread.yield();\n        }\n    }\n}\n\n---\n\n\n## Page 17\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejemplo\n\n*   Aplicación partículas\n    *   Visualiza partículas moviéndose aleatoriamente, de manera continua y autónoma\n    *   Una partícula define un modelo no realista de cuerpos móviles\n        *   Se representa por su posición (x,y)\n        *   Puede cambiar aleatoriamente su posición\n        *   Puede dibujarse como un cuadrado pequeño\n\n&lt;img&gt;Screenshot of a window titled \"Partículas\" showing several small square shapes representing particles moving on a grid.&lt;/img&gt;\n\n```java\npublic class Particle {\n    protected int x;\n    protected int y;\n    protected final Random rng = new Random();\n\n    public Particle(int initialX, int initialY) {\n        x = initialX;\n        y = initialY;\n    }\n\n    public synchronized void move() {\n        x += rng.nextInt(10) - 5;\n        y += rng.nextInt(20) - 10;\n    }\n\n    public void draw(Graphics g) {\n        int lx, ly;\n        synchronized (this) { lx = x; ly = y; }\n        g.drawRect(lx, ly, 10, 10);\n    }\n}\n\n---\n\n\n## Page 18\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejemplo\n\n*   Aplicación partículas\n\n```mermaid\nclassDiagram\n    class java.applet.Applet {\n        AppletParticula\n    }\n    class AppletParticula {\n        init\n        start\n        stop\n    }\n    class java.awt.Canvas {\n        ParticulaCanvas\n    }\n    class ParticulaCanvas {\n        paint\n        particulas *\n    }\n    class Particula {\n        x, y\n        mover\n        dibujar\n    }\n    class java.lang.Thread {\n        start\n        interrupt\n        sleep ...\n    }\n    class (anónimo).Runnable {\n        run\n    }\n    class java.lang.Runnable {\n        run\n    }\n    class java.applet.AppletParticula {\n        canvas -> ParticulaCanvas\n        particulas * -> Particula\n        hilos * -> java.lang.Thread\n        java.lang.Thread : runnable -> (anónimo).Runnable\n    }\n```\n\n&lt;page_number&gt;18&lt;/page_number&gt;\n\n---\n\n\n## Page 19\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejemplo\n\n*   Aplicación partículas\n    *   Movimiento de las partículas\n        *   Asociar un bucle independiente a cada partícula\n\n```mermaid\nsequenceDiagram\n    particulas ->> hilo:Runnable\n    particulas->>interaction frame\n    interaction frame->>p:Particula\n    p->>lienzo:ParticulaCanvas\n    lienzo->>java.awt\n    lienzo-->>evento awt\n    lienzo ->>p\n    p->dibujar\n    dibujar->lienzo\n    lienzo -->> paint\n    lienzo --> lienzo\n    lienzointerrupt\n    lienzo->sleep\n    sleep->lienzo\n\n---\n\n\n## Page 20\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejemplo\n\n*   Asociar un bucle independiente a cada partícula\n\n```java\nprotected Thread[] threads;\nprotected final ParticleCanvas canvas;\n\n...\n\n// Método utilidad\nprotected Thread makeThread(final Particle p) {\n    Runnable runloop = new Runnable() {\n        public void run() {\n            try {\n                for(;;) {\n                    p.move();\n                    canvas.repaint();\n                    Thread.sleep(100); // 100msec arbitrario\n                }\n            } catch (InterruptedException e) { return; }\n        }\n    };\n    return new Thread(runloop);\n}\n```\n&lt;page_number&gt;20&lt;/page_number&gt;\n\n---\n\n\n## Page 21\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejemplo\n\n*   Asociar un bucle independiente a cada partícula\n\n```java\n...\npublic synchronized void start() {\n    int n = 10;\n    if (threads == null) {\n        Particle[] particles = new Particle[n];\n        for (int i = 0; i < n; ++i)\n            particles[i] = new Particle(50, 50);\n        canvas.setParticles(particles);\n        threads = new Thread[n];\n        for (int i = 0; i < n; ++i) {\n            threads[i] = makeThread(particles[i]);\n            threads[i].start();\n        }\n    }\n}\n\npublic synchronized void stop() {\n    if (threads != null) {\n        for (int i = 0; i < threads.length; ++i)\n            threads[i].interrupt();\n        threads = null;\n    }\n}\n\npublic void finalize(){\n    stop();\n}\n```\n&lt;page_number&gt;21&lt;/page_number&gt;\n\n---\n\n\n## Page 22\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejemplo\n\n*   Interacción con el hilo de eventos de java.awt\n    *   Dos actividades: generar eventos y procesar eventos\n\n<mermaid>\ngraph TD\n    A[Aplicación] -->|Genera Evento awt| B[Cola de eventos]\n    B -->|evento| C[Procesador de eventos]\n    C -->|{for(;;){<br>tomar evento;<br>procesar evento llamando<br>a aplicación;<br>}</br>}| A\n</mermaid>\n\n&lt;page_number&gt;22&lt;/page_number&gt;\n\n---\n\n\n## Page 23\n\n# Estructuras básicas de soporte a la concurrencia en Java: Ejemplo\n\n*   Partículas – Monitor de su ejecución\n\n&lt;img&gt;A screenshot of a thread profiling tool showing multiple threads over time. The timeline ranges from 0:00 to 0:30 [m:s]. Each thread is represented by a colored bar indicating its state:\n    *   AWT-EventQueue-0 (yellow)\n    *   Thread-10 (purple)\n    *   Thread-9 (purple)\n    *   Thread-8 (purple)\n    *   Thread-7 (purple)\n    *   Thread-6 (purple)\n    *   Thread-5 (purple)\n    *   Thread-4 (purple)\n    *   Thread-3 (purple)\n    *   Thread-2 (purple)\n    *   Thread-1 (purple)\n    *   AWT-Windows (green)\n    *   AWT-Shutdown (yellow)\n    *   Java2D Disposer (yellow)\n    *   Attach Listener (green)\n    *   Signal Dispatcher (green)\n    *   Finalizer (yellow)\n    *   Reference Handler (yellow)\n\nThe legend at the bottom indicates the color coding:\n*   Running (green)\n*   Sleeping (purple)\n*   Wait (yellow)\n*   Monitor (red)&lt;/img&gt;\n\n&lt;page_number&gt;23&lt;/page_number&gt;\n\n---\n\n\n## Page 24\n\n# Objetos y concurrencia\n## Concurrencia\n\n*   Un programa concurrente\n    *   Es un programa que hace más de una cosa a la vez\n    *   Ejemplo: Navegador Web\n        *   - Petición http para acceder a página html + ejecutar audio + ....\n*   La maquina virtual Java (MVJ) y el sistema operativo subyacente hacen posible la simultaneidad aparente\n    *   Paralelismo físico o tiempo compartido\n*   Programación concurrente (PRGC) vs. Programación distribuida (PRGD)\n    *   PRGC en Java se restringen a estructuras que afectan a una sola JVM\n    *   PRGD múltiples JVM en distintos sistemas informáticos\n\n&lt;page_number&gt;24&lt;/page_number&gt;\n\n---\n\n\n## Page 25\n\n# Objetos y concurrencia\n## Concurrencia\n\n*   Aplicaciones concurrentes y su motivación\n    *   Servicios Web\n        *   Demonios http, servidores de aplicaciones\n        *   Soportar múltiples conexiones concurrentes para no esperar la terminación de una conexión para empezar otra\n        *   Mejorar tiempos de latencia del servicio\n    *   Cálculo numérico\n        *   Tareas intensivas de cálculo\n        *   Maximizar rendimiento haciendo uso de paralelismo real de CPU\n    *   Procesamiento de entrada-salida\n        *   Dispositivos de E/S independientes CPU (paralelismo)\n        *   Uso eficiente de los recursos\n\n&lt;page_number&gt;25&lt;/page_number&gt;\n\n---\n\n\n## Page 26\n\n# Objetos y concurrencia\n## Concurrencia\n\n*   Aplicaciones concurrentes y motivos\n    *   Simulación\n        *   Objetos físicos con comportamientos autónomos independientes\n    *   Aplicaciones basadas en GUI\n        *   Permite el uso de componentes gráficos incluso con acciones disparadas con eventos gráficos que consuman mucho tiempo\n    *   Software basado en componentes\n        *   Componente editor multimedia integrado en aplicación\n        *   Mejorar autonomía y funcionamiento\n    *   Código móvil\n        *   Java . applet descarga de código mediante hilos separados\n        *   Aislar y controlar los efectos de código desconocido\n    *   Sistemas en empotrados\n        *   Pequeños dispositivos que realizan tareas en tiempo real\n\n&lt;page_number&gt;26&lt;/page_number&gt;\n\n---\n\n\n## Page 27\n\nObjetos y concurrencia\nEstructuras para la ejecución concurrente\n\n<mermaid>\ngraph TD\n    subgraph \" \"\n        A[llamada] --> B[tarea]\n        C[llamada] --> D[tarea]\n        E[llamada] --> F[tarea]\n        G[llamada] --> H[tarea]\n        I[llamada] --> J[tarea]\n        K[llamada] --> L[tarea]\n        M[llamada] --> N[tarea]\n        O[llamada] --> P[tarea]\n        Q[llamada] --> R[tarea]\n        S[llamada] --> T[tarea]\n        U[llamada] --> V[tarea]\n        W[llamada] --> X[tarea]\n        Y[llamada] --> Z[tarea]\n    end\n\n    subgraph \" \"\n        B --> AA[hilo]\n        D --> AB[hilo]\n        F --> AC[hilo]\n        H --> AD[hilo]\n        J --> AE[hilo]\n        L --> AF[hilo]\n        N --> AG[hilo]\n        P --> AH[hilo]\n        R --> AI[hilo]\n        T --> AJ[hilo]\n        V --> AK[hilo]\n        X --> AL[hilo]\n    end\n\n    subgraph \" \"\n        AA --> BB[proceso]\n        AB --> CC[proceso]\n        AC --> DD[proceso]\n        AD --> EE[proceso]\n        AE --> FF[proceso]\n        AF --> GG[proceso]\n        AG --> HH[proceso]\n        AH --> II[proceso]\n        AI --> JJ[proceso]\n        AJ --> KK[proceso]\n        AK --> LL[proceso]\n        AL --> MM[proceso]\n    end\n\n    subgraph \" \"\n        BB --> NN[sistema soluciones distribuidas]\n        CC --> OO[sistema soluciones distribuidas]\n        DD --> PP[sistema soluciones distribuidas]\n        EE --> QQ[sistema soluciones distribuidas]\n        FF --> RR[sistema soluciones distribuidas]\n        GG --> SS[sistema soluciones distribuidas]\n        HH --> TT[sistema soluciones distribuidas]\n        II --> UU[sistema soluciones distribuidas]\n        JJ --> VV[sistema soluciones distribuidas]\n        KK --> WW[sistema soluciones distribuidas]\n        LL --> XX[sistema soluciones distribuidas]\n        MM --> YY[sistema soluciones distribuidas]\n    end\n</mermaid>\n\n&lt;page_number&gt;27&lt;/page_number&gt;\n\n---\n\n\n## Page 28\n\n# Objetos y concurrencia\n## Estructuras para la ejecución concurrente\n\n*   Características de las estructuras\n    *   Autonomía e independencia\n    *   Administración de la estructura\n        *   Planificación\n        *   Creación, gestión y comunicación\n*   Capacidad para compartir recursos subyacentes\n    *   CPU's, memoria, canales E/S\n*   Comunicación entre las mismas estructuras\n    *   Canales (sockets) – paso de mensajes\n    *   Áreas de memoria compartidas\n    *   Mecanismos de sincronización basados en memoria\n        *   Cerrojos – mecanismos de espera y notificación\n\n&lt;page_number&gt;28&lt;/page_number&gt;\n\n---\n\n\n## Page 29\n\n# Objetos y concurrencia\n## Concurrencia y programación OO\n\n*   Historia de los lenguajes de programación concurrente\n    *   Simula (1966) → C, C++ → Ada\n*   Diferencias en programación secuencial OO\n    *   Ejecuciones no deterministas\n    *   Comprensión de código no es secuencial\n    *   Las interferencias entre las actividades necesitan diseño conservador\n        *   Sentencia de asignación depende de actividades\n*   Programación basada en eventos\n    *   Múltiples diseños\n        *   Múltiples hilos de bucles de eventos\n        *   Procesando concurrentemente cada uno de los eventos\n    *   Efectos secundarios de interferencias y coordinación entre actividades concurrente\n\n&lt;page_number&gt;29&lt;/page_number&gt;\n\n---\n\n\n## Page 30\n\n# Objetos y concurrencia\n## Concurrencia y programación OO\n\n*   Programación de sistemas concurrentes\n    *   Diferencia de programación multihilo de C\n        -   Incluye construcciones que permiten\n            *   Encapsulación\n            *   Modularidad\n            *   Extensibilidad\n            *   Seguridad\n    *   En Java el soporte a la concurrencia está en el propio lenguaje\n        -   Similar a las bibliotecas de los pthreads POSIX\n*   Otros lenguajes de programación concurrente\n    *   Cada uno define sus propias características de concurrencia\n    *   Se puede simular características de concurrencia a través de bibliotecas y convenciones de codificación\n        -   Semáforos, barreras...\n\n&lt;page_number&gt;30&lt;/page_number&gt;\n\n---\n\n\n## Page 31\n\n# Objetos y concurrencia\n## Transformaciones y modelos de objetos\n\n*   Objetos software vs. objetos reales\n    *   Sólo se consideran las características en el campo de la computación\n        *   Atributos\n        *   Restricciones de estado invariantes\n        *   Operaciones\n        *   Conexiones con otros objetos\n        *   Precondiciones y postcondiciones sobre las operaciones\n        *   Protocolos\n            *   Relacionados con tiempo\n            *   Relacionado con operaciones\n\n&lt;img&gt;A diagram showing two rectangular objects connected by arrows. The larger object on the left has \"capacidad\" written vertically on its side, and \"volumenActual\" written vertically on its front face. It contains a blue rectangle representing water, with \"añadirAgua\" written vertically on the arrow pointing to it, and \"quitarAgua\" written vertically on the arrow pointing away from it. The smaller object on the right also contains a blue rectangle representing water, with \"desbordamiento\" written vertically on the arrow pointing to it.&lt;/img&gt;\n&lt;page_number&gt;31&lt;/page_number&gt;\n\n---\n\n\n## Page 32\n\n# Objetos y concurrencia\n## Transformaciones y modelos de objetos\n\n*   Modelos de Objetos – TanqueAgua\n    *   Estructura estática – atributos y métodos\n    *   Encapsulación\n    *   Comunicación – paso de mensajes\n    *   Identidad\n    *   Conexiones – canal que permite el paso de mensajes\n    *   Acciones\n        *   Aceptar un mensaje\n        *   Actualizar el estado\n        *   Enviar un mensaje\n        *   Crear un objeto\n\n```mermaid\nclassDiagram\n  class TanqueAgua {\n    -capacidad\n    -volumenActual\n    +añadirAgua\n    +quitarAgua\n  }\n  TanqueAgua \"1\" -- \"*\" desbordamiento : desbordamiento\n```\n\n```java\npublic class TanqueAgua {\n    private final float CAPACIDAD;\n    private float volumenActual;\n    private TanqueAgua desbordamiento;\n\n    public TanqueAgua(float cap) {\n        CAPACIDAD = cap;\n        volumenActual = 0.0f;\n    }\n\n    public void añadirAgua(float cantidad) throws ExcepcionDesbordamiento {\n        // Implementación del método añadirAgua\n    }\n\n    public void quitarAgua(float cantidad) throws ExcepcionVacia {\n        // Implementación del método quitarAgua\n    }\n}\n```\n&lt;page_number&gt;32&lt;/page_number&gt;\n\n---\n\n\n## Page 33\n\n# Objetos y concurrencia\n## Transformaciones y modelos de objetos\n\n*   Transformaciones secuenciales\n    *   El computador de propósito general (CPU, bus, memoria, E/S) aparenta ser cualquier un objeto\n        -   Carga el descriptor de la clase .class\n        -   Construir representación pasiva de una instancia\n        -   Interpretar las operaciones\n*   JVM es en sí misma un objeto que finge ser cualquier objeto\n\nJVM Secuencial\n\n<mermaid>\ngraph TD\n    subgraph JVM Secuencial\n        A[Interprete]\n        B[Estado: Contador de Programa Dirección de Objetos]\n        C[Interpretar{...}]\n        D[Objeto representación de un TanqueAgua]\n        E[Clase]\n        F[Clase de]\n        G[Clase representación de un TanqueAgua]\n\n        A --> B\n        A --> C\n        C --> D\n        C --> E\n        E --> F\n        F --> G\n        G --> A\n    end\n</mermaid>\n\n&lt;page_number&gt;33&lt;/page_number&gt;\n\n---\n\n\n## Page 34\n\n# Objetos y concurrencia\n## Transformaciones y modelos de objetos\n\n*   Modelo de objetos activos o modelo de actores\n    *   Cada objeto es autónomo\n    *   Cada uno es tan potente como una JVM secuencial\n        *   Una clase y la representación del objeto pueden ser la misma que la usada en entornos pasivos\n    *   Sistemas distribuidos – problemas de localización y dominio de administración del objeto\n    *   Mensajes mediante comunicación remota\n        *   Sockets\n\n```mermaid\ngraph TD\n    subgraph \" \"\n        direction LR\n        A[Objeto activo]\n        B[Atributos y conexiones]\n        C[unaAccion () {\n            actualizar estado\n            enviar mensaje\n            crear objetos\n        }]\n        D[Acepta Mensajes]\n        E[mensaje]\n    end\n    A --> B\n    B --> C\n    C --> D\n    D --> E\n    E --> A\n```\n\n&lt;page_number&gt;34&lt;/page_number&gt;\n\n---\n\n\n## Page 35\n\n# Objetos y concurrencia\n## Transformaciones y modelos de objetos\n\n*   Modelos mixtos\n    *   Una JVM puede estar compuesta de múltiples hilos\n    *   Los hilos comparten las representaciones subyacentes\n        *   Una clase y la representación del objeto pueden ser la misma que la usada en entornos pasivos\n    *   Se separan objetos normales/pasivos de los activos/hilos\n        *   Protección de objetos pasivos de coincidencia de hilos mediante cerrojos\n        *   Objetos activos más simples sólo soportan una operación `run()`\n*   Direcciones del diseño concurrente\n    1.  Que los objetos pasivos vivan en un contexto multihilo\n    2.  \"silenciando\" objetos activos para que puedan ser expresados en estructuras de hilo\n\n&lt;page_number&gt;35&lt;/page_number&gt;\n\n---\n\n\n## Page 36\n\n# Objetos y concurrencia\n## Transformaciones y modelos de objetos\n\n*   Modelos mixtos\n    *   El grado de control del desarrollador sobre estas transformaciones es un rasgo de distinción entre programación concurrente y paralela\n    *   La programación concurrente deja la mayoría de las transformaciones a la JVM y al SO subyacente\n\n<mermaid>\ngraph TD\n    subgraph JVM Concurrente\n        Hilo1[Estado del Hilo]\n        Run1[Run ( ){ ... }]\n        Hilo2[Estado del Hilo]\n        Run2[Run ( ){ ... }]\n    end\n\n    subgraph Clase representación de un TanqueAgua\n        Clase1[Clase representación de un TanqueAgua]\n        Clase2[Clase representación de un TanqueAgua]\n    end\n\n    Hilo1 --> Run1\n    Hilo2 --> Run2\n\n    Run1 --> Clase1\n    Run2 --> Clase2\n\n    Clase1 -- \"...\" --> Clase2\n</mermaid>\n\n&lt;page_number&gt;36&lt;/page_number&gt;\n\n---\n\n\n## Page 37\n\n# Imposiciones de diseño\n\n*   Programación secuencial vs. Programación concurrente\n    *   Aparecen nuevos problemas de diseño\n*   Dos perspectivas complementarias de un sistema orientado a objetos\n    *   Centrado en objetos – conjunto de objetos\n    *   Centrado en la actividad – conjunto de actividades\n        *   - Mensajes, cadenas de llamadas, secuencia eventos, tareas, sesiones...\n\nSistemas = Objetos + Actividades\n\n&lt;page_number&gt;37&lt;/page_number&gt;\n\n---\n\n\n## Page 38\n\n# Imposiciones de diseño\n\n*   Las dos perspectiva son complementarias\n    *   Un objeto se puede implicar en varias actividades\n    *   Una actividad puede atravesar múltiples objetos\n\n<mermaid>\ngraph TD\n    subgraph Legend\n        L1[Objects]\n        L2[Activities]\n        L3[Connections between objects]\n    end\n\n    A1(( )) -- L1 --> A1_obj1\n    A1 -- L2 --> A1_act1\n    A1 -- L3 --> A1_conn1\n\n    A2(( )) -- L1 --> A2_obj2\n    A2 -- L2 --> A2_act2\n    A2 -- L3 --> A2_conn2\n\n    A3(( )) -- L1 --> A3_obj3\n    A3 -- L2 --> A3_act3\n    A3 -- L3 --> A3_conn3\n\n    A4(( )) -- L1 --> A4_obj4\n    A4 -- L2 --> A4_act4\n    A4 -- L3 --> A4_conn4\n\n    A5(( )) -- L1 --> A5_obj5\n    A5 -- L2 --> A5_act5\n    A5 -- L3 --> A5_conn5\n\n    A6(( )) -- L1 --> A6_obj6\n    A6 -- L2 --> A6_act6\n    A6 -- L3 --> A6_conn6\n\n    A7(( )) -- L1 --> A7_obj7\n    A7 -- L2 --> A7_act7\n    A7 -- L3 --> A7_conn7\n\n    A8(( )) -- L1 --> A8_obj8\n    A8 -- L2 --> A8_act8\n    A8 -- L3 --> A8_conn8\n\n    A9(( )) -- L1 --> A9_obj9\n    A9 -- L2 --> A9_act9\n    A9 -- L3 --> A9_conn9\n\n    A10(( )) -- L1 --> A10_obj10\n    A10 -- L2 --> A10_act10\n    A10 -- L3 --> A10_conn10\n\n    A11(( )) -- L1 --> A11_obj11\n    A11 -- L2 --> A11_act11\n    A11 -- L3 --> A11_conn11\n\n    A12(( )) -- L1 --> A12_obj12\n    A12 -- L2 --> A12_act12\n    A12 -- L3 --> A12_conn12\n\n    A13(( )) -- L1 --> A13_obj13\n    A13 -- L2 --> A13_act13\n    A13 -- L3 --> A13_conn13\n\n    A14(( )) -- L1 --> A14_obj14\n    A14 -- L2 --> A14_act14\n    A14 -- L3 --> A14_conn14\n\n    A15(( )) -- L1 --> A15_obj15\n    A15 -- L2 --> A15_act15\n    A15 -- L3 --> A15_conn15\n\n    A16(( )) -- L1 --> A16_obj16\n    A16 -- L2 --> A16_act16\n    A16 -- L3 --> A16_conn16\n\n    A17(( )) -- L1 --> A17_obj17\n    A17 -- L2 --> A17_act17\n    A17 -- L3 --> A17_conn17\n\n    A18(( )) -- L1 --> A18_obj18\n    A18 -- L2 --> A18_act18\n    A18 -- L3 --> A18_conn18\n\n    A19(( )) -- L1 --> A19_obj19\n    A19 -- L2 --> A19_act19\n    A19 -- L3 --> A19_conn19\n\n    A20(( )) -- L1 --> A20_obj20\n    A20 -- L2 --> A20_act20\n    A20 -- L3 --> A20_conn20\n\n    A21(( )) -- L1 --> A21_obj21\n    A21 -- L2 --> A21_act21\n    A21 -- L3 --> A21_conn21\n\n    A22(( )) -- L1 --> A22_obj22\n    A22 -- L2 --> A22_act22\n    A22 -- L3 --> A22_conn22\n\n    A23(( )) -- L1 --> A23_obj23\n    A23 -- L2 --> A23_act23\n    A23 -- L3 --> A23_conn23\n\n    A24(( )) -- L1 --> A24_obj24\n    A24 -- L2 --> A24_act24\n    A24 -- L3 --> A24_conn24\n\n    A25(( )) -- L1 --> A25_obj25\n    A25 -- L2 --> A25_act25\n    A25 -- L3 --> A25_conn25\n\n    A26(( )) -- L1 --> A26_obj26\n    A26 -- L2 --> A26_act26\n    A26 -- L3 --> A26_conn26\n\n    A27(( )) -- L1 --> A27_obj27\n    A27 -- L2 --> A27_act27\n    A27 -- L3 --> A27_conn27\n\n    A28(( )) -- L1 --> A28_obj28\n    A28 -- L2 --> A28_act28\n    A28 -- L3 --> A28_conn28\n\n    A29(( )) -- L1 --> A29_obj29\n    A29 -- L2 --> A29_act29\n    A29 -- L3 --> A29_conn29\n\n    A30(( )) -- L1 --> A30_obj30\n    A30 -- L2 --> A30_act30\n    A30 -- L3 --> A30_conn30\n\n    A31(( )) -- L1 --> A31_obj31\n    A31 -- L2 --> A31_act31\n    A31 -- L3 --> A31_conn31\n\n    A32(( )) -- L1 --> A32_obj32\n    A32 -- L2 --> A32_act32\n    A32 -- L3 --> A32_conn32\n\n    A33(( )) -- L1 --> A33_obj33\n    A33 -- L2 --> A33_act33\n    A33 -- L3 --> A33_conn33\n\n    A34(( )) -- L1 --> A34_obj34\n    A34 -- L2 --> A34_act34\n    A34 -- L3 --> A34_conn34\n\n    A35(( )) -- L1 --> A35_obj35\n    A35 -- L2 --> A35_act35\n    A35 -- L3 --> A35_conn35\n\n    A36(( )) -- L1 --> A36_obj36\n    A36 -- L2 --> A36_act36\n    A36 -- L3 --> A36_conn36\n\n    A37(( )) -- L1 --> A37_obj37\n    A37 -- L2 --> A37_act37\n    A37 -- L3 --> A37_conn37\n\n    A38(( )) -- L1 --> A38_obj38\n    A38 -- L2 --> A38_act38\n    A38 -- L3 --> A38_conn38\n\n    A39(( )) -- L1 --> A39_obj39\n    A39 -- L2 --> A39_act39\n    A39 -- L3 --> A39_conn39\n\n    A40(( )) -- L1 --> A40_obj40\n    A40 -- L2 --> A40_act40\n    A40 -- L3 --> A40_conn40\n\n    A41(( )) -- L1 --> A41_obj41\n    A41 -- L2 --> A41_act41\n    A41 -- L3 --> A41_conn41\n\n    A42(( )) -- L1 --> A42_obj42\n    A42 -- L2 --> A42_act42\n    A42 -- L3 --> A42_conn42\n\n    A43(( )) -- L1 --> A43_obj43\n    A43 -- L2 --> A43_act43\n    A43 -- L3 --> A43_conn43\n\n    A44(( )) -- L1 --> A44_obj44\n    A44 -- L2 --> A44_act44\n    A44 -- L3 --> A44_conn44\n\n    A45(( )) -- L1 --> A45_obj45\n    A45 -- L2 --> A45_act45\n    A45 -- L3 --> A45_conn45\n\n    A46(( )) -- L1 --> A46_obj46\n    A46 -- L2 --> A46_act46\n    A46 -- L3 --> A46_conn46\n\n    A47(( )) -- L1 --> A47_obj47\n    A47 -- L2 --> A47_act47\n    A47 -- L3 --> A47_conn47\n\n    A48(( )) -- L1 --> A48_obj48\n    A48 -- L2 --> A48_act48\n    A48 -- L3 --> A48_conn48\n\n    A49(( )) -- L1 --> A49_obj49\n    A49 -- L2 --> A49_act49\n    A49 -- L3 --> A49_conn49\n\n    A50(( )) -- L1 --> A50_obj50\n    A50 -- L2 --> A50_act50\n    A50 -- L3 --> A50_conn50\n\n    A51(( )) -- L1 --> A51_obj51\n    A51 -- L2 --> A51_act51\n    A51 -- L3 --> A51_conn51\n\n    A52(( )) -- L1 --> A52_obj52\n    A52 -- L2 --> A52_act52\n    A52 -- L3 --> A52_conn52\n\n    A53(( )) -- L1 --> A53_obj53\n    A53 -- L2 --> A53_act53\n    A53 -- L3 --> A53_conn53\n\n    A54(( )) -- L1 --> A54_obj54\n    A54 -- L2 --> A54_act54\n    A54 -- L3 --> A54_conn54\n\n    A55(( )) -- L1 --> A55_obj55\n    A55 -- L2 --> A55_act55\n    A55 -- L3 --> A55_conn55\n\n    A56(( )) -- L1 --> A56_obj56\n    A56 -- L2 --> A56_act56\n    A56 -- L3 --> A56_conn56\n\n    A57(( )) -- L1 --> A57_obj57\n    A57 -- L2 --> A57_act57\n    A57 -- L3 --> A57_conn57\n\n    A58(( )) -- L1 --> A58_obj58\n    A58 -- L2 --> A58_act58\n    A58 -- L3 --> A58_conn58\n\n    A59(( )) -- L1 --> A59_obj59\n    A59 -- L2 --> A59_act59\n    A59 -- L3 --> A59_conn59\n\n    A60(( )) -- L1 --> A60_obj60\n    A60 -- L2 --> A60_act60\n    A60 -- L3 --> A60_conn60\n\n    A61(( )) -- L1 --> A61_obj61\n    A61 -- L2 --> A61_act61\n    A61 -- L3 --> A61_conn61\n\n    A62(( )) -- L1 --> A62_obj62\n    A62 -- L2 --> A62_act62\n    A62 -- L3 --> A62_conn62\n\n    A63(( )) -- L1 --> A63_obj63\n    A63 -- L2 --> A63_act63\n    A63 -- L3 --> A63_conn63\n\n    A64(( )) -- L1 --> A64_obj64\n    A64 -- L2 --> A64_act64\n    A64 -- L3 --> A64_conn64\n\n    A65(( )) -- L1 --> A65_obj65\n    A65 -- L2 --> A65_act65\n    A65 -- L3 --> A65_conn65\n\n    A66(( )) -- L1 --> A66_obj66\n    A66 -- L2 --> A66_act66\n    A66 -- L3 --> A66_conn66\n\n    A67(( )) -- L1 --> A67_obj67\n    A67 -- L2 --> A67_act67\n    A67 -- L3 --> A67_conn67\n\n    A68(( )) -- L1 --> A68_obj68\n    A68 -- L2 --> A68_act68\n    A68 -- L3 --> A68_conn68\n\n    A69(( )) -- L1 --> A69_obj69\n    A69 -- L2 --> A69_act69\n    A69 -- L3 --> A69_conn69\n\n    A70(( )) -- L1 --> A70_obj70\n    A70 -- L2 --> A70_act70\n    A70 -- L3 --> A70_conn70\n\n    A71(( )) -- L1 --> A71_obj71\n    A71 -- L2 --> A71_act71\n    A71 -- L3 --> A71_conn71\n\n    A72(( )) -- L1 --> A72_obj72\n    A72 -- L2 --> A72_act72\n    A72 -- L3 --> A72_conn72\n\n    A73(( )) -- L1 --> A73_obj73\n    A73 -- L2 --> A73_act73\n    A73 -- L3 --> A73_conn73\n\n    A74(( )) -- L1 --> A74_obj74\n    A74 -- L2 --> A74_act74\n    A74 -- L3 --> A74_conn74\n\n    A75(( )) -- L1 --> A75_obj75\n    A75 -- L2 --> A75_act75\n    A75 -- L3 --> A75_conn75\n\n    A76(( )) -- L1 --> A76_obj76\n    A76 -- L2 --> A76_act76\n    A76 -- L3 --> A76_conn76\n\n    A77(( )) -- L1 --> A77_obj77\n    A77 -- L2 --> A77_act77\n    A77 -- L3 --> A77_conn77\n\n    A78(( )) -- L1 --> A78_obj78\n    A78 -- L2 --> A78_act78\n    A78 -- L3 --> A78_conn78\n\n    A79(( )) -- L1 --> A79_obj79\n    A79 -- L2 --> A79_act79\n    A79 -- L3 --> A79_conn79\n\n    A80(( )) -- L1 --> A80_obj80\n    A80 -- L2 --> A80_act80\n    A80 -- L3 --> A80_conn80\n\n    A81(( )) -- L1 --> A81_obj81\n    A81 -- L2 --> A81_act81\n    A81 -- L3 --> A81_conn81\n\n    A82(( )) -- L1 --> A82_obj82\n    A82 -- L2 --> A82_act82\n    A82 -- L3 --> A82_conn82\n\n    A83(( )) -- L1 --> A83_obj83\n    A83 -- L2 --> A83_act83\n    A83 -- L3 --> A83_conn83\n\n    A84(( )) -- L1 --> A84_obj84\n    A84 -- L2 --> A84_act84\n    A84 -- L3 --> A84_conn84\n\n    A85(( )) -- L1 --> A85_obj85\n    A85 -- L2 --> A85_act85\n    A85 -- L3 --> A85_conn85\n\n    A86(( )) -- L1 --> A86_obj86\n    A86 -- L2 --> A86_act86\n    A86 -- L3 --> A86_conn86\n\n    A87(( )) -- L1 --> A87_obj87\n    A87 -- L2 --> A87_act87\n    A87 -- L3 --> A87_conn87\n\n    A88(( )) -- L1 --> A88_obj88\n    A88 -- L2 --> A88_act88\n    A88 -- L3 --> A88_conn88\n\n    A89(( )) -- L1 --> A89_obj89\n    A89 -- L2 --> A89_act89\n    A89 -- L3 --> A89_conn89\n\n    A90(( )) -- L1 --> A90_obj90\n    A90 -- L2 --> A90_act90\n    A90 -- L3 --> A90_conn90\n\n    A91(( )) -- L1 --> A91_obj91\n    A91 -- L2 --> A91_act91\n    A91 -- L3 --> A91_conn91\n\n    A92(( )) -- L1 --> A92_obj92\n    A92 -- L2 --> A92_act92\n    A92 -- L3 --> A92_conn92\n\n    A93(( )) -- L1 --> A93_obj93\n    A93 -- L2 --> A93_act93\n    A93 -- L3 --> A93_conn93\n\n    A94(( )) -- L1 --> A94_obj94\n    A94 -- L2 --> A94_act94\n    A94 -- L3 --> A94_conn94\n\n    A95(( )) -- L1 --> A95_obj95\n    A95 -- L2 --> A95_act95\n    A95 -- L3 --> A95_conn95\n\n    A96(( )) -- L1 --> A96_obj96\n    A96 -- L2 --> A96_act96\n    A96 -- L3 --> A96_conn96\n\n    A97(( )) -- L1 --> A97_obj97\n    A97 -- L2 --> A97_act97\n    A97 -- L3 --> A97_conn97\n\n    A98(( )) -- L1 --> A98_obj98\n    A98 -- L2 --> A98_act98\n    A98 -- L3 --> A98_conn98\n\n    A99(( )) -- L1 --> A99_obj99\n    A99 -- L2 --> A99_act99\n    A99 -- L3 --> A99_conn99\n\n    A100(( )) -- L1 --> A100_obj100\n    A100 -- L2 --> A100_act100\n    A100 -- L3 --> A100_conn100\n\n    A101(( )) -- L1 --> A101_obj101\n    A101 -- L2 --> A101_act101\n    A101 -- L3 --> A101_conn101\n\n    A102(( )) -- L1 --> A102_obj102\n    A102 -- L2 --> A102_act102\n    A102 -- L3 --> A102_conn102\n\n    A103(( )) -- L1 --> A103_obj103\n    A103 -- L2 --> A103_act103\n    A103 -- L3 --> A103_conn103\n\n    A104(( )) -- L1 --> A104_obj104\n    A104 -- L2 --> A104_act104\n    A104 -- L3 --> A104_conn104\n\n    A105(( )) -- L1 --> A105_obj105\n    A105 -- L2 --> A105_act105\n    A105 -- L3 --> A105_conn105\n\n    A106(( )) -- L1 --> A106_obj106\n    A106 -- L2 --> A106_act106\n    A106 -- L3 --> A106_conn106\n\n    A107(( )) -- L1 --> A107_obj107\n    A107 -- L2 --> A107_act107\n    A107 -- L3 --> A107_conn107\n\n    A108(( )) -- L1 --> A108_obj108\n    A108 -- L2 --> A108_act108\n    A108 -- L3 --> A108_conn108\n\n    A109(( )) -- L1 --> A109_obj109\n    A109 -- L2 --> A109_act109\n    A109 -- L3 --> A109_conn109\n\n    A110(( )) -- L1 --> A110_obj110\n    A110 -- L2 --> A110_act110\n    A110 -- L3 --> A110_conn110\n\n    A111(( )) -- L1 --> A111_obj111\n    A111 -- L2 --> A111_act111\n    A111 -- L3 --> A111_conn111\n\n    A112(( )) -- L1 --> A112_obj112\n    A112 -- L2 --> A112_act112\n    A112 -- L3 --> A112_conn112\n\n    A113(( )) -- L1 --> A113_obj113\n    A113 -- L2 --> A113_act113\n    A113 -- L3 --> A113_conn113\n\n    A114(( )) -- L1 --> A114_obj114\n    A114 -- L2 --> A114_act114\n    A114 -- L3 --> A114_conn114\n\n    A115(( )) -- L1 --> A115_obj115\n    A115 -- L2 --> A115_act115\n    A115 -- L3 --> A115_conn115\n\n    A116(( )) -- L1 --> A116_obj116\n    A116 -- L2 --> A116_act116\n    A116 -- L3 --> A116_conn116\n\n    A117(( )) -- L1 --> A117_obj117\n    A117 -- L2 --> A117_act117\n    A117 -- L3 --> A117_conn117\n\n    A118(( )) -- L1 --> A118_obj118\n    A118 -- L2 --> A118_act118\n    A118 -- L3 --> A118_conn118\n\n    A119(( )) -- L1 --> A119_obj119\n    A119 -- L2 --> A119_act119\n    A119 -- L3 --> A119_conn119\n\n    A120(( )) -- L1 --> A120_obj120\n    A120 -- L2 --> A120_act120\n    A120 -- L3 --> A120_conn120\n\n    A121(( )) -- L1 --> A121_obj121\n    A121 -- L2 --> A121_act121\n    A121 -- L3 --> A121_conn121\n\n    A122(( )) -- L1 --> A122_obj122\n    A122 -- L2 --> A122_act122\n    A122 -- L3 --> A122_conn122\n\n    A123(( )) -- L1 --> A123_obj123\n    A123 -- L2 --> A123_act123\n    A123 -- L3 --> A123_conn123\n\n    A124(( )) -- L1 --> A124_obj124\n    A124 -- L2 --> A124_act124\n    A124 -- L3 --> A124_conn124\n\n    A125(( )) -- L1 --> A125_obj125\n    A125 -- L2 --> A125_act125\n    A125 -- L3 --> A125_conn125\n\n    A126(( )) -- L1 --> A126_obj126\n    A126 -- L2 --> A126_act126\n    A126 -- L3 --> A126_conn126\n\n    A127(( )) -- L1 --> A127_obj127\n    A127 -- L2 --> A127_act127\n    A127 -- L3 --> A127_conn127\n\n    A128(( )) -- L1 --> A128_obj128\n    A128 -- L2 --> A128_act128\n    A128 -- L3 --> A128_conn128\n\n    A129(( )) -- L1 --> A129_obj129\n    A129 -- L2 --> A129_act129\n    A129 -- L3 --> A129_conn129\n\n    A130(( )) -- L1 --> A130_obj130\n    A130 -- L2 --> A130_act130\n    A130 -- L3 --> A130_conn130\n\n    A131(( )) -- L1 --> A131_obj131\n    A131 -- L2 --> A131_act131\n    A131 -- L3 --> A131_conn131\n\n    A132(( )) -- L1 --> A132_obj132\n    A132 -- L2 --> A132_act132\n    A132 -- L3 --> A132_conn132\n\n    A133(( )) -- L1 --> A133_obj133\n    A133 -- L2 --> A133_act133\n    A133 -- L3 --> A133_conn133\n\n    A134(( )) -- L1 --> A134_obj134\n    A134 -- L2 --> A134_act134\n    A134 -- L3 --> A134_conn134\n\n    A135(( )) -- L1 --> A135_obj135\n    A135 -- L2 --> A135_act135\n    A135 -- L3 --> A135_conn135\n\n    A136(( )) -- L1 --> A136_obj136\n    A136 -- L2 --> A136_act136\n    A136 -- L3 --> A136_conn136\n\n    A137(( )) -- L1 --> A137_obj137\n    A137 -- L2 --> A137_act137\n    A137 -- L3 --> A137_conn137\n\n    A138(( )) -- L1 --> A138_obj138\n    A138 -- L2 --> A138_act138\n    A138 -- L3 --> A138_conn138\n\n    A139(( )) -- L1 --> A139_obj139\n    A139 -- L2 --> A139_act139\n    A139 -- L3 --> A139_conn139\n\n    A140(( )) -- L1 --> A140_obj140\n    A140 -- L2 --> A140_act140\n    A140 -- L3 --> A140_conn140\n\n    A141(( )) -- L1 --> A141_obj141\n    A141 -- L2 --> A141_act141\n    A141 -- L3 --> A141_conn141\n\n    A142(( )) -- L1 --> A142_obj142\n    A142 -- L2 --> A142_act142\n    A142 -- L3 --> A142_conn142\n\n    A143(( )) -- L1 --> A143_obj143\n    A143 -- L2 --> A143_act143\n    A143 -- L3 --> A143_conn143\n\n    A144(( )) -- L1 --> A144_obj144\n    A144 -- L2 --> A144_act144\n    A144 -- L3 --> A144_conn144\n\n    A145(( )) -- L1 --> A145_obj145\n    A145 -- L2 --> A145_act145\n    A145 -- L3 --> A145_conn145\n\n    A146(( )) -- L1 --> A146_obj146\n    A146 -- L2 --> A146_act146\n    A146 -- L3 --> A146_conn146\n\n    A147(( )) -- L1 --> A147_obj147\n    A147 -- L2 --> A147_act147\n    A147 -- L3 --> A147_conn147\n\n    A148(( )) -- L1 --> A148_obj148\n    A148 -- L2 --> A148_act148\n    A148 -- L3 --> A148_conn148\n\n    A149(( )) -- L1 --> A149_obj149\n    A149 -- L2 --> A149_act149\n    A149 -- L3 --> A149_conn149\n\n    A150(( )) -- L1 --> A150_obj150\n    A150 -- L2 --> A150_act150\n    A150 -- L3 --> A150_conn150\n\n    A151(( )) -- L1 --> A151_obj151\n    A151 -- L2 --> A151_act151\n    A151 -- L3 --> A151_conn151\n\n    A152(( )) -- L1 --> A152_obj152\n    A152 -- L2 --> A152_act152\n    A152 -- L3 --> A152_conn152\n\n    A153(( )) -- L1 --> A153_obj153\n    A153 -- L2 --> A153_act153\n    A153 -- L3 --> A153_conn153\n\n    A154(( )) -- L1 --> A154_obj154\n    A154 -- L2 --> A154_act154\n    A154 -- L3 --> A154_conn154\n\n    A155(( )) -- L1 --> A155_obj155\n    A155 -- L2 --> A155_act155\n    A155 -- L3 --> A155_conn155\n\n    A156(( )) -- L1 --> A156_obj156\n    A156 -- L2 --> A156_act156\n    A156 -- L3 --> A156_conn156\n\n    A157(( )) -- L1 --> A157_obj157\n    A157 -- L2 --> A157_act157\n    A157 -- L3 --> A157_conn157\n\n    A158(( )) -- L1 --> A158_obj158\n    A158 -- L2 --> A158_act158\n    A158 -- L3 --> A158_conn158\n\n    A159(( )) -- L1 --> A159_obj159\n    A159 -- L2 --> A159_act159\n    A159 -- L3 --> A159_conn159\n\n    A160(( )) -- L1 --> A160_obj160\n    A160 -- L2 --> A160_act160\n    A160 -- L3 --> A160_conn160\n\n    A161(( )) -- L1 --> A161_obj161\n    A161 -- L2 --> A161_act161\n    A161 -- L3 --> A161_conn161\n\n    A162(( )) -- L1 --> A162_obj162\n    A162 -- L2 --> A162_act162\n    A162 -- L3 --> A162_conn162\n\n    A163(( )) -- L1 --> A163_obj163\n    A163 -- L2 --> A163_act163\n    A163 -- L3 --> A163_conn163\n\n    A164(( )) -- L1 --> A164_obj164\n    A164 -- L2 --> A164_act164\n    A164 -- L3 --> A164_conn164\n\n    A165(( )) -- L1 --> A165_obj165\n    A165 -- L2 --> A165_act165\n    A165 -- L3 --> A165_conn165\n\n    A166(( )) -- L1 --> A166_obj166\n    A166 -- L2 --> A166_act166\n    A166 -- L3 --> A166_conn166\n\n    A167(( )) -- L1 --> A167_obj167\n    A167 -- L2 --> A167_act167\n    A167 -- L3 --> A167_conn167\n\n    A168(( )) -- L1 --> A168_obj168\n    A168 -- L2 --> A168_act168\n    A168 -- L3 --> A168_conn168\n\n    A169(( )) -- L1 --> A169_obj169\n    A169 -- L2 --> A169_act169\n    A169 -- L3 --> A169_conn169\n\n    A170(( )) -- L1 --> A170_obj170\n    A170 -- L2 --> A170_act170\n    A170 -- L3 --> A170_conn170\n\n    A171(( )) -- L1 --> A171_obj171\n    A171 -- L2 --> A171_act171\n    A171 -- L3 --> A171_conn171\n\n    A172(( )) -- L1 --> A172_obj172\n    A172 -- L2 --> A172_act172\n    A172 -- L3 --> A172_conn172\n\n    A173(( )) -- L1 --> A173_obj173\n    A173 -- L2 --> A173_act173\n    A173 -- L3 --> A173_conn173\n\n    A174(( )) -- L1 --> A174_obj174\n    A174 -- L2 --> A174_act174\n    A174 -- L3 --> A174_conn174\n\n    A175(( )) -- L1 --> A175_obj175\n    A175 -- L2 --> A175_act175\n    A175 -- L3 --> A175_conn175\n\n    A176(( )) -- L1 --> A176_obj176\n    A176 -- L2 --> A176_act176\n    A176 -- L3 --> A176_conn176\n\n    A177(( )) -- L1 --> A177_obj177\n    A177 -- L2 --> A177_act177\n    A177 -- L3 --> A177_conn177\n\n    A178(( )) -- L1 --> A178_obj178\n    A178 -- L2 --> A178_act178\n    A178 -- L3 --> A178_conn178\n\n    A179(( )) -- L1 --> A179_obj179\n    A179 -- L2 --> A179_act179\n    A179 -- L3 --> A179_conn179\n\n    A180(( )) -- L1 --> A180_obj180\n    A180 -- L2 --> A180_act180\n    A180 -- L3 --> A180_conn180\n\n    A181(( )) -- L1 --> A181_obj181\n    A181 -- L2 --> A181_act181\n    A181 -- L3 --> A181_conn181\n\n    A182(( )) -- L1 --> A182_obj182\n    A182 -- L2 --> A182_act182\n    A182 -- L3 --> A182_conn182\n\n    A183(( )) -- L1 --> A183_obj183\n    A183 -- L2 --> A183_act183\n    A183 -- L3 --> A183_conn183\n\n    A184(( )) -- L1 --> A184_obj184\n    A184 -- L2 --> A184_act184\n    A184 -- L3 --> A184_conn184\n\n    A185(( )) -- L1 --> A185_obj185\n    A185 -- L2 --> A185_act185\n    A185 -- L3 --> A185_conn185\n\n    A186(( )) -- L1 --> A186_obj186\n    A186 -- L2 --> A186_act186\n    A186 -- L3 --> A186_conn186\n\n    A187(( )) -- L1 --> A187_obj187\n    A187 -- L2 --> A187_act187\n    A187 -- L3 --> A187_conn187\n\n    A188(( )) -- L1 --> A188_obj188\n    A188 -- L2 --> A188_act188\n    A188 -- L3 --> A188_conn188\n\n    A189(( )) -- L1 --> A189_obj189\n    A189 -- L2 --> A189_act189\n    A189 -- L3 --> A189_conn189\n\n    A190(( )) -- L1 --> A190_obj190\n    A190 -- L2 --> A190_act190\n    A190 -- L3 --> A190_conn190\n\n    A191(( )) -- L1 --> A191_obj191\n    A191 -- L2 --> A191_act191\n    A191 -- L3 --> A191_conn191\n\n    A192(( )) -- L1 --> A192_obj192\n    A192 -- L2 --> A192_act192\n    A192 -- L3 --> A192_conn192\n\n    A193(( )) -- L1 --> A193_obj193\n    A193 -- L2 --> A193_act193\n    A193 -- L3 --> A193_conn193\n\n    A194(( )) -- L1 --> A194_obj194\n    A194 -- L2 --> A194_act194\n    A194 -- L3 --> A194_conn194\n\n    A195(( )) -- L1 --> A195_obj195\n    A195 -- L2 --> A195_act195\n    A195 -- L3 --> A195_conn195\n\n    A196(( )) -- L1 --> A196_obj196\n    A196 -- L2 --> A196_act196\n    A196 -- L3 --> A196_conn196\n\n    A197(( )) -- L1 --> A197_obj197\n    A197 -- L2 --> A197_act197\n    A197 -- L3 --> A197_conn197\n\n    A198(( )) -- L1 --> A198_obj198\n    A198 -- L2 --> A198_act198\n    A198 -- L3 --> A198_conn198\n\n    A199(( )) -- L1 --> A199_obj199\n    A199 -- L2 --> A199_act199\n    A199 -- L3 --> A199_conn199\n\n    A200(( )) -- L1 --> A200_obj200\n    A200 -- L2 --> A200_act200\n    A200 -- L3 --> A200_conn200\n\n    A201(( )) -- L1 --> A201_obj201\n    A201 -- L2 --> A201_act201\n    A201 -- L3 --> A201_conn201\n\n    A202(( )) -- L1 --> A202_obj202\n    A202 -- L2 --> A202_act202\n    A202 -- L3 --> A202_conn202\n\n    A203(( )) -- L1 --> A203_obj203\n    A203 -- L2 --> A203_act203\n    A203 -- L3 --> A203_conn203\n\n    A204(( )) -- L1 --> A204_obj204\n    A204 -- L2 --> A204_act204\n    A204 -- L3 --> A204_conn204\n\n    A205(( )) -- L1 --> A205_obj205\n    A205 -- L2 --> A205_act205\n    A205 -- L3 --> A205_conn205\n\n    A206(( )) -- L1 --> A206_obj206\n    A206 -- L2 --> A206_act206\n    A206 -- L3 --> A206_conn206\n\n    A207(( )) -- L1 --> A207_obj207\n    A207 -- L2 --> A207_act207\n    A207 -- L3 --> A207_conn207\n\n    A208(( )) -- L1 --> A208_obj208\n    A208 -- L2 --> A208_act208\n    A208 -- L3 --> A208_conn208\n\n    A209(( )) -- L1 --> A209_obj209\n    A209 -- L2 --> A209_act209\n    A209 -- L3 --> A209_conn209\n\n    A210(( )) -- L1 --> A210_obj210\n    A210 -- L2 --> A210_act210\n    A210 -- L3 --> A210_conn210\n\n    A211(( )) -- L1 --> A211_obj211\n    A211 -- L2 --> A211_act211\n    A211 -- L3 --> A211_conn211\n\n    A212(( )) -- L1 --> A212_obj212\n    A212 -- L2 --> A212_act212\n    A212 -- L3 --> A212_conn212\n\n    A213(( )) -- L1 --> A213_obj213\n    A213 -- L2 --> A213_act213\n    A213 -- L3 --> A213_conn213\n\n    A214(( )) -- L1 --> A214_obj214\n    A214 -- L2 --> A214_act214\n    A214 -- L3 --> A214_conn214\n\n    A215(( )) -- L1 --> A215_obj215\n    A215 -- L2 --> A215_act215\n    A215 -- L3 --> A215_conn215\n\n    A216(( )) -- L1 --> A216_obj216\n    A216 -- L2 --> A216_act216\n    A216 -- L3 --> A216_conn216\n\n    A217(( )) -- L1 --> A217_obj217\n    A217 -- L2 --> A217_act217\n    A217 -- L3 --> A217_conn217\n\n    A218(( )) -- L1 --> A218_obj218\n    A218 -- L2 --> A218_act218\n    A218 -- L3 --> A218_conn218\n\n    A219(( )) -- L1 --> A219_obj219\n    A219 -- L2 --> A219_act219\n    A219 -- L3 --> A219_conn219\n\n    A220(( )) -- L1 --> A220_obj220\n    A220 -- L2 --> A220_act220\n    A220 -- L3 --> A220_conn220\n\n    A221(( )) -- L1 --> A221_obj221\n    A221 -- L2 --> A221_act221\n    A221 -- L3 --> A221_conn221\n\n    A222(( )) -- L1 --> A222_obj222\n    A222 -- L2 --> A222_act222\n    A222 -- L3 --> A222_conn222\n\n    A223(( )) -- L1 --> A223_obj223\n    A223 -- L2 --> A223_act223\n    A223 -- L3 --> A223_conn223\n\n    A224(( )) -- L1 --> A224_obj224\n    A224 -- L2 --> A224_act224\n    A224 -- L3 --> A224_conn224\n\n    A225(( )) -- L1 --> A225_obj225\n    A225 -- L2 --> A225_act225\n    A225 -- L3 --> A225_conn225\n\n    A226(( )) -- L1 --> A226_obj226\n    A226 -- L2 --> A226_act226\n    A226 -- L3 --> A226_conn226\n\n    A227(( )) -- L1 --> A227_obj227\n    A227 -- L2 --> A227_act227\n    A227 -- L3 --> A227_conn227\n\n    A228(( )) -- L1 --> A228_obj228\n    A228 -- L2 --> A228_act228\n    A228 -- L3 --> A228_conn228\n\n    A229(( )) -- L1 --> A229_obj229\n    A229 -- L2 --> A229_act229\n    A229 -- L3 --> A229_conn229\n\n    A230(( )) -- L1 --> A230_obj230\n    A230 -- L2 --> A230_act230\n    A230 -- L3 --> A230_conn230\n\n    A231(( )) -- L1 --> A231_obj231\n    A231 -- L2 --> A231_act231\n    A231 -- L3 --> A231_conn231\n\n    A232(( )) -- L1 --> A232_obj232\n    A232 -- L2 --> A232_act232\n    A232 -- L3 --> A232_conn232\n\n    A233(( )) -- L1 --> A233_obj233\n    A233 -- L2 --> A233_act233\n    A233 -- L3 --> A233_conn233\n\n    A234(( )) -- L1 --> A234_obj234\n    A234 -- L2 --> A234_act234\n    A234 -- L3 --> A234_conn234\n\n    A235(( )) -- L1 --> A235_obj235\n    A235 -- L2 --> A235_act235\n    A235 -- L3 --> A235_conn235\n\n    A236(( )) -- L1 --> A236_obj236\n    A236 -- L2 --> A236_act236\n    A236 -- L3 --> A236_conn236\n\n    A237(( )) -- L1 --> A237_obj237\n    A237 -- L2 --> A237_act237\n    A237 -- L3 --> A237_conn237\n\n    A238(( )) -- L1 --> A238_obj238\n    A238 -- L2 --> A238_act238\n    A238 -- L3 --> A238_conn238\n\n    A239(( )) -- L1 --> A239_obj239\n    A239 -- L2 --> A239_act239\n    A239 -- L3 --> A239_conn239\n\n    A240(( )) -- L1 --> A240_obj240\n    A240 -- L2 --> A240_act240\n    A240 -- L3 --> A240_conn240\n\n    A241(( )) -- L1 --> A241_obj241\n    A241 -- L2 --> A241_act241\n    A241 -- L3 --> A241_conn241\n\n    A242(( )) -- L1 --> A242_obj242\n    A242 -- L2 --> A242_act242\n    A242 -- L3 --> A242_conn242\n\n    A243(( )) -- L1 --> A243_obj243\n    A243 -- L2\n\n---\n\n\n## Page 39\n\n# Imposiciones de diseño\n\n*   Las estrategias de diseño son complementarias\n    *   Diseño respecto a la corrección\n        *   Seguridad – nunca sucede nada malo a un objeto\n        *   Vivacidad – algo sucede eventualmente dentro de una actividad\n        *   La elección de la estrategia complementaria depende del balance de efectos de fallos\n            *   Por defecto se prima la seguridad\n            *   Ejemplo para primar vivacidad respecto a seguridad barra de progreso\n    *   Diseño respecto a la calidad\n        *   Reutilización – utilización de objetos y de clases en múltiples contextos\n        *   Rendimiento – grado en que las actividades se ejecutan pronto y rápidamente\n\n&lt;page_number&gt;39&lt;/page_number&gt;\n\n---\n\n\n## Page 40\n\n# Imposiciones de diseño Seguridad\n\n*   A la seguridad en programación concurrente se agrega una dimensión temporal\n*   Objetivo en la preservación de la seguridad\n\nAsegurar que todos los objetos del sistema mantienen estados coherentes\n\nEstado coherente – todos los campos del objeto y todos los campos de los otros objetos de los cuales depende, poseen valores legales y significativos\n\n<mermaid>\ngraph TD\n    subgraph \" \"\n        direction LR\n        A[ ] -- métodos --> B(( ))\n        B -- Estados del objeto --> C[ ]\n        C -- Actividades --> D[ ]\n    end\n\n    subgraph \" \" direction LR\n        E[método 1]\n        F[método 2]\n        G[método 3]\n        H(legal)\n        I(temp)\n        J(legal)\n        K(temp)\n    end\n\n    A --- E\n    A --- F\n    A --- G\n\n    E --> H\n    F --> I\n    G --> J\n\n    H --> I\n    J --> K\n\n    I -- \"???\" --> K\n    K --> A\n</mermaid>\n\n&lt;page_number&gt;40&lt;/page_number&gt;\n\n---\n\n\n## Page 41\n\n# Imposiciones de diseño\n## Seguridad\n\n*   “Valores legales” implica cumplir invariantes a nivel conceptual\n    *   VolumenActual >= 0 AND VolumenActual <= Capacidad\n*   Un método público cambia el estado del objeto\n    *   añadirAgua, quitarAgua\n\nEn programación se necesitan técnicas de protección para garantizar valores legales (cumplir los invariantes)\n\n&lt;img&gt;A diagram showing two water containers. The left container has \"capacidad\" written on its side, with \"volumenActual\" partially filled with blue liquid. An arrow labeled \"añadirAgua\" points to this container. The right container also has \"capacidad\" written on its side, but \"volumenActual\" is completely full, with an arrow labeled \"desbordamiento\" pointing to it. An arrow labeled \"quitarAgua\" points from the left container towards the right one.&lt;/img&gt;\n\n&lt;page_number&gt;41&lt;/page_number&gt;\n\n---\n\n\n## Page 42\n\n# Imposiciones de diseño\n## Seguridad\n\nTécnicas de protección para garantizar valores legales (cumplir los invariantes)\n\n1. Procesamiento de excepciones (prg. secuencial) &lt;img&gt;Circle&lt;/img&gt;\n\n2. Técnicas de exclusión para garantizar la atomicidad de las acciones públicas (prg. concurrente) &lt;img&gt;Arrow pointing left&lt;/img&gt;\n\n- Cada acción se ejecuta hasta la terminación sin interferencia de otras\n- Nuevos problemas por condiciones de competencia producen conflictos de almacenamiento a bajo nivel\n  - Lectura/Escritura\n    - Un hilo lee el valor de un campo mientras otro escribe en el mismo, es difícil prever el valor leído\n  - Escritura/Escritura\n    - Dos hilos intentan escribir en el mismo campo es difícil conocer el valor de la siguiente lectura\n\n&lt;page_number&gt;42&lt;/page_number&gt;\n\n---\n\n\n## Page 43\n\n# Imposiciones de diseño\n## Seguridad\n\n*   Compreensión de atributos y restricciones conceptuales\n    *   Una CuentaBancaria tiene un saldo que es igual a la suma de todos los depósitos e intereses menos los reintegros y gastos de servicios\n    *   Un Paquete tiene un destino que tiene que ser una dirección IP\n    *   Un Contador tiene un valor entero no negativo\n    *   Un Termostato tiene una temperatura igual a la lectura más reciente del sensor\n    *   Una Figura tiene una posición, dimensión y color que obedece a una serie de pautas de estilo correspondientes a un juego de herramientas GUI\n    *   Un BufferLimitado siempre tiene un contadordeelementos entre cero y una capacidad\n\n&lt;page_number&gt;43&lt;/page_number&gt;\n\n---\n\n\n## Page 44\n\n# Imposiciones de diseño Seguridad\n\n*   Comprensión sobre las restricciones de representación\n    *   Pueden aparecer nuevos invariantes adicionales por decisiones de implementación\n    *   Categorías de campos y restricciones\n        *   Directas del valor: Buffer indiceInsertar\n        *   De valores derivados CuentaBancaria saldoDeudor\n        *   Representaciones lógicas de estado LectorTarjeta pinValido, JuegoTablero turno\n        *   Variables sobre el estado de ejecución. Enumeración CONECTANDO, ACTUALIZANDO, ESPERANDO\n        *   Variables históricas CuentaBancaria ultimoSaldoRegistrado\n        *   Variables para el seguimiento Termostato numeroLectura\n        *   Referencias a relaciones ManejadorPeticiones WebServer\n        *   Referencias a relaciones de objetos\n            *   CuentaBancaria referencia a un campo de tipo Deposito\n\n&lt;page_number&gt;44&lt;/page_number&gt;\n\n---\n\n\n## Page 45\n\n# Imposiciones de diseño\n## Vivacidad\n\n*   Los problemas de seguridad se tienen que equilibrar con problemas de vivacidad\n*   En sistemas vivaces, cada actividad progresa hacia la terminación\n    *   De forma transitoria, una actividad puede no progresar\n        *   Bloqueo synchronized un hilo adquiere un cerrojo\n        *   Espera Object.wait\n        *   Entrada por un método de E/S\n        *   Competencia de CPU\n        *   Fallo\n\nEl ciclo de vida de un hilo puede incluir un número de bloqueos transitorios &lt;page_number&gt;45&lt;/page_number&gt;\n\n---\n\n\n## Page 46\n\n# Imposiciones de diseño\n## Vivacidad\n\n*   Problemas de vivacidad o de bloqueo permanente\n    *   Interbloqueo\n        *   Dependencias circulares cerrojos\n    *   Señales perdidas\n        *   Un hilo empieza a esperar después de la notificación para que despierte\n    *   Cerrojos anidados en un monitor\n        *   Un hilo que espera para adquirir un cerrojo que podría ser necesitado por cualquier otro hilo que trata de despertarlo\n\n&lt;page_number&gt;46&lt;/page_number&gt;\n\n---\n\n\n## Page 47\n\n# Imposiciones de diseño\n## Vivacidad\n\n*   Problemas de vivacidad o de bloqueo permanente\n    *   Falta de vivacidad\n        *   Una acción repetida falla continuamente\n    *   Inanición\n        *   JVM no puede asignar CPU\n    *   Falta de recursos\n        *   Los hilos tienen un límite de recursos\n    *   Fallo distribuido\n        *   No accesible máquina remota conectada mediante socket\n\n&lt;page_number&gt;47&lt;/page_number&gt;\n\n---\n\n\n## Page 48\n\n# Imposiciones de diseño\n## Rendimiento\n\n*   Las imposiciones de rendimiento amplían los problemas de vivacidad\n    *   Además de exigir que cada método se ejecute, los objetivos del rendimiento es que se ejecute pronto y rápido\n*   Medidas de rendimiento\n    *   Productividad, latencia, capacidad, eficiencia, escalabilidad, degradación\n*   En los diseños concurrentes multihilo se empeora la **eficiencia** para mejorar la **latencia**\n\n&lt;page_number&gt;48&lt;/page_number&gt;\n\n---\n\n\n## Page 49\n\n# Imposiciones de diseño\n## Rendimiento\n\n*   El soporte de concurrencia introduce **sobrecarga**\n    *   Cerrojos mayor sobrecarga métodos synchronized\n    *   Monitores Object.wait, Object.notify, Object.notifyAll pueden ser más costosos que otras operaciones JVM\n    *   Cambio de contexto la asignación de hilos a CPU\n    *   Planificación cálculos y políticas de asignación de hilos\n    *   Localización en sistemas multiprocesadores múltiples hilos que comparten acceso a objetos\n    *   Algoritmos secuenciales eficientes no sirven para contextos concurrentes\n\nMinimizar el uso de estructuras concurrentes para adecuarse a las medidas de rendimiento &lt;page_number&gt;49&lt;/page_number&gt;\n\n---\n\n\n## Page 50\n\n# Imposiciones de diseño\n## Reutilización\n\n*   Una clase o un objeto es reutilizable cuando puede ser utilizado fácilmente en distintos **contextos**\n    *   Componentes de caja negra\n    *   Extensión de caja blanca por medio de herencia\n*   La dualidad entre seguridad y vivacidad dificulta la reutilización\n    *   Un componente seguro no puede reutilizarse por no ser vivaz en todos los **contextos**\n*   Alternativas de diseño de sistemas concurrentes\n    *   Basados en seguridad → sistemas lentos\n    *   Basados en vivacidad → ejecuciones incorrectas\n\nDocumentar los contextos de uso de los componentes &lt;page_number&gt;50&lt;/page_number&gt;\n\n---\n\n\n## Page 51\n\n# Imposiciones de diseño\n## Reutilización\n\n*   Tendencias para abordar la dependencia del contexto\n    1.  Reducir incertidumbre aislando parte del sistema\n        *   Subsistemas cerrados\n        *   Comunicación externa restringida\n        *   Estructura interna/estática determinista: nº objetos + nº hilos\n        *   Seguros pero frágiles si cambia comunicación\n        *   Ejemplo sistemas empotrados\n\n&lt;img&gt;A diagram showing three interconnected circles (subsystems) with arrows indicating communication between them. The left circle is labeled \"Componente cerrado\" (Closed Component). A legend on the right explains:\n    *   Objetos (Objects)\n    *   Actividades (Activities)\n    *   Conexiones entre objetos (Connections between objects)&lt;/img&gt;\n\n&lt;page_number&gt;51&lt;/page_number&gt;\n\n---\n\n\n## Page 52\n\n# Imposiciones de diseño\n## Reutilización\n\n2.- Establecer las políticas y protocolos que permitan a los componentes seguir siendo accesibles\n\n- Sistemas abiertos\n- Imposible determinar un análisis estático puesto que naturaleza y estructura se desarrollan a través del tiempo\n- Dominio de políticas\n    * Flujo los componentes de tipo A envían mensajes a los componentes de tipo B\n    * Bloqueo los métodos de tipo A siempre lanzan excepciones si el recurso R no está disponible\n    * Notificaciones los objetos de tipo A siempre envían notificaciones de cambio a sus oyentes siempre que estén actualizados\n- Ejemplo internet\n\n&lt;page_number&gt;52&lt;/page_number&gt;\n\n---\n\n\n## Page 53\n\n# Bibliografía\n\n*   **Libros y manuales**\n    *   Doug Lea. Programación concurrente en Java: Principios y patrones de diseño. 2ª ed. PEARSON EDUCACION, 2000.\n        http://gee.cs.oswego.edu/dl/cpj/.\n    *   Oracle. «Lesson: Concurrency (The Java™ Tutorials > Essential Classes)». Accedido enero 23, 2013.\n        http://docs.oracle.com/javase/tutorial/essential/concurrency/index.html.\n\n*   **Enlaces de interés**\n    *   «Java Concurrent Animated | Free Home & Education software downloads at SourceForge.net». Accedido enero 23, 2013.\n        http://sourceforge.net/projects/javaconcurrenta/.\n\n&lt;page_number&gt;53&lt;/page_number&gt;",
      "metadata": {}
    }
  }
}