investigacion Programacion concurrente topicos avanzados de programacion

1. UNIDAD IV: INVESTIGACION
Anel Verónica Sosa Mejía
8 DE MAYO DE 2016
ITSP
Ing. Enrique Ponce rivera

2. Contenido
Unidad IV Programación concurrente (Multihilo).......................................... 2
4.1. Concepto de hilo..................................................................................... 2
Estados de los Hilos:.................................................................................... 3
4.2Programas De Flujo Único......................................................................... 3
4.3Creacion y control de hilos ....................................................................... 3
4.4. Sincronización de hilos............................................................................ 5
Uso de métodos synchronized.................................................................... 5
Declaración synchronized ........................................................................... 5
BIBLIOGRAFIA ................................................................................................ 5

3. Unidad IV Programación concurrente (Multihilo)
4.1. Concepto de hilo.
Un programa multihilo contiene dos o más partes que se pueden ejecutar de manera concurrente o simultánea.
A cada parte del programa se le denomina como hilo (thread).
La programación multihilo es una forma especializada de multitarea.
Existe multitarea basada en procesos y basada en hilos.
Basada en procesos, permite que se puedan ejecutar dos o más programas a la vez de manera concurrente.
Multitarea basada en hilos es la unidad más pequeña de código que se puede seleccionar, de tal forma que
Un mismo programa puede realizar dos o más tareas de forma simultánea.
(Por ejemplo un editor puede dar formato y estar imprimiendo al mismo tiempo).

4. Estados de los Hilos:
- Nuevo (new): Este es el estado en que un hilo se encuentra después de que un objeto de la clase
Thread ha sido instanciado pero antes de que el método start()sea llamado.
- En ejecución (runnable): Este es el estado en que un hilo puede ser elegido para ser ejecutado por el
programador de hilos pero aún no está corriendo en el procesador. Se obtiene este estado
inmediatamente después de hacer la llamada al método start() de una instancia de la clase Thread.
- Ejecutándose (running): Este es el estado en el que el hilo está realizando lo que debe de hacer, es
decir, está realizando el trabajo para el cual fue diseñado.
- Esperando/bloqueado/dormido (waiting/blocked/sleeping): Es el estado en el cual el hilo está vivo aún
pero no es elegible para ser ejecutado, es decir, no está en ejecución pero puede estarlo nuevamente
si algún evento en particular sucede. Por ejemplo, un hilo puede estar durmiendo porque en el código
se le ha pedido que lo haga pero pasa a estado en ejecución cuando el tiempo que se le pidió dormir
ha expirado.
- Muerto (dead): Un hilo está muerto cuando se han completado todos los procesos y operaciones
contenidos en el método run(). Una vez que un hilo ha muerto NO puede volver nunca a estar vivo,
recordemos que no es posible llamar al método start() más de una vez para un solo hilo.
4.2Programas De Flujo Único
Un programa de flujo único, tarea única o mono -hilo (single- thread) utiliza un único flujo de control
(thread) para controlar su ejecución. Muchos programas no necesitan la potencia o utilidad de múltiples
tareas. Sin necesidad para especificar explícitamente que se quiere un único flujo de control, muchos
de los applets y aplicaciones son de flujo único.
4.3Creacion y control de hilos
En Java los hilos están encapsulados en la clase Thread. Para crear un hilo tenemos dos
posibilidades:
 Heredar de Thread redefiniendo el método run().
 Crear una clase que implemente la interfaz Runnable que nos obliga a definir el método run().
En ambos casos debemos definir un método run() que será el que contenga el código del hilo. Desde
dentro de este método podremos llamar a cualquier otro método de cualquier objeto, pero este
métodorun() será el método que se invoque cuando iniciemos la ejecución de un hilo. El hilo
terminará su ejecución cuando termine de ejecutarse este método run().

5. Para crear nuestro hilo mediante herencia haremos lo siguiente:
1
2
3
4
5
6
7
8
public class EjemploHilo extends Thread
{
public void run()()
{
// Código del hilo
}
}
Una vez definida la clase de nuestro hilo deberemos instanciarlo y ejecutarlo de la siguiente forma:
1
2
3
Thread t = new EjemploHilo();
t.start();
Al llamar al método start del hilo, comenzará ejecutarse su método run. Crear un hilo heredando deThread tiene el
problema de que al no haber herencia múltiple en Java, si heredamos de Thread no podremos heredar de ninguna
otra clase, y por lo tanto un hilo no podría heredar de ninguna otra clase.
Este problema desaparece si utilizamos la interfaz Runnable para crear el hilo, ya que una clase puede implementar
varios interfaces. Definiremos la clase que contenga el hilo como se muestra a continuación:
1
2
3
4
5
6
7
8
public class EjemploHilo implements Runnable
{
public void run()
{
// Código del hilo
}
}
Para instanciar y ejecutar un hilo de este tipo deberemos hacer lo siguiente:
1
2
3
Thread t = new Thread(new EjemploHilo());
t.start();
Esto es así debido a que en este caso EjemploHilo no deriva de una clase Thread, por lo que no se puede
considerar un hilo, lo único que estamos haciendo implementando la interfaz es asegurar que vamos a tener definido
el método run(). Con esto lo que haremos será proporcionar esta clase al constructor de la clase Thread, para que el
objeto Thread que creemos llame al método run() de la clase que hemos definido al iniciarse la ejecución del hilo, ya
que implementando la interfaz le aseguramos que esta función existe.

6. 4.4. Sincronización de hilos
Cuando se están utilizando hilos múltiples, algunas veces es necesario coordinar las
actividades de dos o más. El proceso por el cual se logra esto se llama sincronización. La
razón más común para la sincronización es cuando dos o más hilos necesitan acceso a un
recurso compartido que sólo puede ser utilizado por un hilo a la vez. Otra razón para la
sincronización es cuando un hilo está esperando un evento causado por otro hilo. En este
caso, debe de haber algún medio por el cual el primer hilo se mantenga en estado
suspendido hasta que el evento ocurra.
La sincronización esta soportada por la palabra clave synchronized y por unos
cuantos métodos bien definidos que tienen todos los objetos.
Uso de métodos synchronized
Cuando se llama al método Synchronized , el hilo que llama ingresa al monitor de objeto, que
entonces bloquea el objeto. Mientras está bloqueado ningún otro hilo puede ingresar al método, ni
ingresar algún otro método sincronizado definido por el objeto. Cuando el hilo retorna del método, el
monitor desbloquea el objeto permitiendo que sea usado por el próximo hilo.
Los puntos clave de un método sincronizado son:
 Un método sincronizado se crea precediendo su declaración con synchronized.
 Para cualquier objeto dado, una vez un método sincronizado ha sido llamado se bloquea el
objeto, y los métodos no sincronizados dentro del mismo objeto pueden ser utilizados por otros hilos
en ejecución.
 Otros hilos que traten de llamar un objeto sincronizado en uso ingresaría en un estado de
espera, hasta que el objeto se desbloquea.
 Cuando un hilo sale del método sincronizado, el objeto se desbloquea.
Declaración synchronized
La creación del método Synchronized dentro de las clases creadas por nosotros mismos es fácil y
eficiente sin embargo no trabaja en todos los casos. Por ejemplo, podemos querer sincronizar el acceso
a algún método que no este modificado por Synchronized ; esto ocurre cuando queremos utilizar una
clase que no fue creada por nosotros sino por un tercero, y no tenemos acceso al código fuente.
La solución para este problema es poner llamadas a los métodos definidos por esa clase dentro de
un bloque Synchronized.
BIBLIOGRAFIA
Fundamentos de programación en java 2 Autor: Schildt, Herbert Mc Graw Hill