\begin{markdown}

Actividad: Uso del paquete `java.util.concurrent`
=================================================

Objectivos:
:   Comprender cómo se uso el paquete disponible en Java
    `jave.util.concurrent` (y `java.util.concurrent.atomic`
    para resolver problemas de concurrencia ya resueltos con
    métodos más básicos del lenguaje.
    Saber definir tipos de datos simples que sean seguros
    en entornos concurrentes usando sincronización. Conocer las principales
    ventajas de usar dichos paquetes y aspectos de sus eficiencias.

Metodología:
:   Esta práctica se realizará en horas de prácticas presenciales y
    en horas no presenciales.
    El tiempo de dedicación estimada es de 3 semanas. 

Un simple contador concurrente
------------------------------

  #. Elabora una clase `Contador` que tiene un método `Incrementar(n)`
     que ejecuta un bucle de *n* iteraciones que incrementa una variable
     interna cada cierto tiempo, y al acabar devuelve el valor actual
     de dicha variable.

     Elabora un programa que lanza varios hilos que comparten tal
     objeto contador.
     Cada hilo, cada cierto tiempo, debe llamar al método `Incrementar(n)`
     con *n* adecuado e visualizar el valor devuelto por ese método.

     ¿Podemos garantizar que cuando un hilo ejecuta el método `Incrementar()`,
     no interferirá con otro hilo? ¿Cómo podemos solucionarlo?

Uso de hilos (`workers`) para operaciones matriciales
-----------------------------------------

 #. Escribe una clase para matrices cuadradas NxN
    (el valor de N se pasa en el constructor),
    rellenándolas de valores o bien aleatorios o bien de un valor entero
    cualquiera durante la construcción.

 #. Implementa un método de la clase que reciba las dos matrices A y B como
    parámetros, y devuelve una nueva matriz C que será la suma de A+B.
    Cada elemento de la matriz C será la suma de los elementos de la posición
    correspondiente de A y B.

 #. No te olvides verificar que el código realiza la operación correctamente.

 #. Para hacer la suma, este método deberá usar uno o varios hilos
    para realizar el trabajo.

 #. Para los hilos trabajadores se debe usar el paquete
    `java.util.concurrent`.
    El número concreto se pasa como parámetro de línea de comando al
    programa.

 #. El programa deberá mostrar el tiempo empleado para realizar la suma.

 #. Analisa el comportamiento del programa respecto al tiempo de ejecución
    dependiendo del tamaño de las matrices y el número de hilos trabajadores
    comparándolo con la solución de la actividad 2.

Un juego: ping-pong-múltiple
----------------------------

Queremos hacer un programa que simule un juego de ping-pong (pero con mucho
más jugadoras que pasan la pelota entre ellas en un orden preestablecido).
Para ello hemos de definir una clase llamada `Ping` que simulará una jugadora
con su método `run()` que será ejecutado en su hilo.
Es necesario que cada hilo saque un mensaje indicando qué jugadora juega.

Para realizar esta actividad:

  #. Experimenta con el material presentado en clases de teoría.

  #. Usa---parecido al juego real---un objeto que haga de *pelota*,
     de forma que cada jugadora sepa cuando tiene que jugar,
     que será cuando la pelota esté *en su posesión*.

     Averigua para ello cómo se puede usar un objeto en Java para
     sincronizar varios hilos.

  #. Usa el hilo principal con el papel de *árbitro*, es decir,
     es el hilo que inicia el partido.

  #. Implementa un criterio (o varios criterios) de parada, por ejemplo:
     número de jugadas, tiempo de juegadas, interrupción...
     El programa debe terminar todos los hilos participantes de forma
     explícita. Como siempre, el hilo principal termina el programa con
     el último mensaje.

  #. Utiliza en tu solución los métodos del paquete
     `jave.util.concurrent` de Java. ¿Observas diferencias la solución
     a la práctica 3?

  #. Queremos que el árbitro decida quien será el hilo que comience a jugar.

  #. Argumenta de forma semi-formal que tu programa es correcto y
     garantiza la semántica del juego.

  #. Mide el tiempo de ejecución (con un criterio de terminación razonable)
     de tu partido variando el número de jugadoras de unas pocas a unas miles.
     ¿Qué resultado esperas para un número constante
     de *pasar-pelota* independientemente del número de jugadores?
     ¿Qué dicen tus mediciones comparándolos con los resultados de
     la pŕactica 3?

  #. ¿Funciona tu programa con una sola jugadora también? Si no lo hace
     ¿qué deberías cambiar?

\end{markdown}


