UNIDAD IV: INVESTIGACION Anel Verónica Sosa Mejía

8 DE MAYO DE 2016 ITSP

Ing. Enrique Ponce rivera

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

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).

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().

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.

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