Documentos de Académico
Documentos de Profesional
Documentos de Cultura
CCP t4 Jthreads PDF
CCP t4 Jthreads PDF
Tabla de contenidos
1. Soporte para hilos en Java ...................................................................................................... 1
2. Creación y control de un hilo .................................................................................................. 2
2.1. Métodos de creación de un hilo ..................................................................................... 2
2.2. Control de hilos mediante métodos de Thread .................................................................. 2
3. Sincronización por exclusión mutua ......................................................................................... 2
3.1. Sincronización de métodos ........................................................................................... 2
3.2. Sincronización de bloques ............................................................................................ 3
3.3. Sincronización de métodos y bloques estáticos ................................................................. 3
4. Espera y notificación de eventos .............................................................................................. 3
4.1. Wait y notify ............................................................................................................. 3
4.2. NotifyAll .................................................................................................................. 4
4.3. Wait y sleep .............................................................................................................. 4
4.4. Wait y notify en métodos estáticos ................................................................................. 4
5. La integral numérica con hilos ................................................................................................. 4
5.1. Diseño ..................................................................................................................... 4
5.2. La clase NumIntegralTh .............................................................................................. 4
5.3. La clase IntervalTh ..................................................................................................... 5
5.4. La clase IntegralRes .................................................................................................... 6
5.5. Versión en C ............................................................................................................. 6
5.6. Tiempos de ejecución .................................................................................................. 7
Bibliografía .............................................................................................................................7
• Dotando a la clase ancestral Object de los métodos Wait(), Notify() y NotifyAll() que dan soporte a los
eventos
• Asociando un lock a cada clase y a cada objeto, la obtención y la devolución del lock se hace mediante la
utilización de la palabra reservada synchronized mediante la cual se definen métodos o bloques de código a
los que se accede en exclusión mutua
• Proporcionando la clase Thread en la librería java.lang que implementa los mecanismos básicos para realizar
hilos
• La interfaz Runnable permite la creación de hilos en clases que extienden otra clase diferente de Thread
• El control de prioridad
IV-A.1
Procesamiento paralelo con hilos de Java CCP
Tanto Thread como Runnable forman parte de java.lang con lo que no requieren ser importados explícitamente.
Ambos métodos tienen en común el procedimiento básico que consiste en implementar el método run(). El mé-
todo para iniciar el hilo depende de la forma como se halla creado:
• Extendiendo la clase Thread Se llama al método start de los objetos que instancian la clase
• Implementando Runnable Se crea un objeto Thread con el constructor que tiene como parámetro un objeto
Runnable y llamando posteriormente al método start de dicho objeto
En las páginas 15-23 se dispone de un ejemplo en el que se incluye una animación en un Applet utilizando los
dos mecanismos: una clase auxiliar que extiende Thread e implementando Runnable en el propio Applet.
• isAlive Devuelve un valor true si el hilo esta activo, es decir su método run ha sido iniciado con start y toda-
vía no ha finalizado
• join Condiciona la continuación del hilo actual a la terminación de otro hilo, la duración de esta espera se
puede limitar
• setName y getName Permiten dar un nombre a un hilo y obtener dicho nombre, respectivamente. Esto tiene
interés sobre todo para la depuración. La función setName se puede evitar utilizando los constructores ade-
cuados de Thread (pag 30)
• sleep Detiene la ejecución del hilo que hace la llamada durante el tiempo que se especifica
• currentThread Permite identificar al hilo que hace la llamada (ejemplo en la página 31)
• enumerate Devuelve una matriz con referencias a todos los hilos creados por el programa (no necesaria-
mente activos) y su número
• activeCount Devuelve el número de hilos creados por el programa (no necesariamente activos)
IV-A.2
CCP Procesamiento paralelo con hilos de Java
Este mecanismo asegura que la modificación del estado del objeto se realiza de forma consistente evitando las
condiciones de carrera ya que solamente un objeto puede estar ejecutando en un momento dado un método sin-
cronizado, o sea que no puede haber simultáneamente dos o mas objetos ejecutando métodos sincronizados (el
mismo método o diferentes métodos) de forma simultánea.
Esta serialización del acceso a los métodos sincronizados asegura la evitación de condiciones de carrera, aunque
por otra parte reduce las posibilidades de paralelismo en la utilización del objeto.
El funcionamiento de esto consiste en que al iniciar un método sincronizado se toma el lock asociado al objeto y
al finalizar se devuelve el lock dejándolo disponible.
• Permite elegir el objeto cuyo lock se va a utilizar en la sincronización (no ha de ser necesariamente this)
Hay que evitar que el objeto cuyo lock se utiliza en synchonized sea null, y también tener cuidado ya que las re-
ferencias a objetos pueden cambiar en tiempo de ejecución y por tanto los efectos sobre la sincronización pue-
den generar errores.
Los bloques de código dentro de un método estático pueden sincronizarse haciendo uso del objeto mencionado:
public class Ejemplo {
void proceso() {
....
synchronized (Class.forName("Ejemplo")) {
.....
}
....
}
}
IV-A.3
Procesamiento paralelo con hilos de Java CCP
Ambos métodos han de llamarse desde código sincronizado con el mismo lock para asegurar que el test de la
condición y la entrada en espera se realizan en exclusión mutua. La función wait() libera el lock antes de iniciar
la espera y retoma el lock después de recibir la notificación.
En las páginas 67-68 se tiene una versión de un semáforo con espera ocupada para la operación get. La versión
con wait de la página 70 evita la espera ocupada y requiere sincronizar el método. Obsérvese que wait está en un
bucle en el que después de salir de wait se vuelve a testear la condición.
4.2. NotifyAll
Cuando hay varios hilos en espera de la misma condición no es posible saber cual de ellos recibirá la notifica-
ción.
El método NotifyAll permite notificar a todos los hilos en espera que han utilizado el mismo lock, será el mismo
lock que se ha utilizado para sincronizar el código que incluye la llamada a NotifyAll.
En la página 75 se tiene la clase ResourceThrottle como ejemplo de utilización de NotifyAll. Todos los hilos
son notificados pero sólo uno de los que demandan un número igual o menor de los recursos disponibles saldrá
de la espera.
En las páginas 76-77 se tiene la clase TargetNotify que implementa un mecanismo de espera y notificación se-
lectivo.
Esta versión de wait funciona como sleep con la diferencia de que wait no retiene el lock, por lo que se puede
utilizar dentro de un método sincronizado a diferencia de sleep.
Sin embargo, se pueden utilizar los métodos wait y notify asociados a un objeto estático como en el ejemplo
MyStaticClass de la página 86 que ofrece los métodos staticWait y staticNotify que pueden utilizarse en méto-
dos estáticos.
• La clase NumIntegralTh que es la clase principal con el método main que lanza los hilos
IV-A.4
CCP Procesamiento paralelo con hilos de Java
IV-A.5
Procesamiento paralelo con hilos de Java CCP
return integral;
}
public void run() {
double h;
double local_a;
double local_b;
int local_n;
double integral;
h = (b - a)/(double)n;
local_n = n / p;
local_a = a + (double)id * local_n * h;
local_b = local_a + local_n * h;
integral = Trap (local_a, local_b, local_n, h);
res.update(integral);
}
}
5.5. Versión en C
#include <stdio.h>
#include <time.h>
#include <math.h>
double f(double x) {
double y;
y = log(sin(x*x+1));
y = sqrt(y*y);
return y;
}
int main(int argc, char* argv[]) {
double integral;
float a;
float b;
int n;
double h;
double x;
int i;
clock_t t0, t1;
float t;
a = 0.0; b = 0.0; n = 0;
printf ("Enter a, b and n\n");
scanf ("%f %f %d", &a, &b, &n);
printf ("of the integral from %f to %f\n", a, b);
t0 = clock();
h = ((double)b-(double)a)/(double)n;
integral = (f(a) + f(b)) / 2.0;
x = a;
for (i=1; i<n-1; i++) {
x = x + h;
integral = integral + f(x);
IV-A.6
CCP Procesamiento paralelo con hilos de Java
}
integral = integral * h;
t1 = clock();
t = (float)((1000*t1)/CLOCKS_PER_SEC) - (float)((1000*t0)/CLOCKS_PER_SEC);
Bibliografía
Scott Oaks, Henry Wong "Java Threads" O'Reilly
Doug Lea "Concurrent Programming in Java: Design Principles and Patterns" Addison-Wesley
IV-A.7