Java

Intermedio

1
Contenido
●
●
●
●
●
3

Exceptions

Cuando un programa Java que se está ejecutando (runtime) viola las

restricciones semánticas del lenguaje (se produce un error), la máquina virtual
de Java comunica este hecho al programa mediante una Excepción.

Como por ejemplo cuando se hace una división entre cero, cuando un objeto
es “null” y no puede serlo, cuando no se abre correctamente un fichero, etc.
Cuando se produce la máquina virtual de Java crea un objeto de la clase
Exception.
 Cuando en Java se produce una excepción se crear un objeto de una
determina clase (dependiendo del tipo de error que se haya producido), que
mantendrá la información sobre el error producido y nos proporcionará los
métodos necesarios para obtener dicha información.
Estas clases tienen como clase padre la clase Throwable, por tanto se
mantiene una jerarquía en las excepciones.

Throwable

Error Exception ...

AssetionError OutOfMemoryError RuntimeException ... IOException

... ArithmeticException NullPointerException ... EOFException ...

Clase base que representa todo lo que se puede “lanzar” en Java

● Contiene una instancia del estado de la pila en el momento en el que se

creó el objeto( “stack trace” o “call chain”).
● Almacena un mensaje ( variable de instancia de tipo String) que podemos
utilizar para detallar qué error se produjo.
● Puede tener una causa, también del tipo Throwable, que permite
representar el error que causó este error.

Un Error es una subclase de Throwable que indica problemas serios que

ocurren en la Máquina Virtual de Java y no en el programa, Este tipo de
excepciones escapan del control del programa por lo tanto no deberás de
tratar de solucionarlas. La mayoría de estos errores son condiciones
anormales.
Ya que estos errores son condiciones anormales que nunca deberían ocurrir
no es necesario implementar métodos de control y captura de estos errores.
 Error

● Error
● VirtualMachineError
● OutofMemoryError
● InternalError
● UnknownError
● AssertionError
● StackOverflowError

Exception es una subclase de Throwable que indica situaciones que una

aplicacion deberia de controlar, este tipo de excepciones son del control del
programa por lo tanto deberás de tratar de capturarlas y gestionarlas de
forma correcta.
Los dos tipos principales de excepciones son:
● Unchecked Exception
● Checked Exception
La excepción no verificada en Java son aquellas excepciones cuyo manejo
NO se verifica durante el tiempo de compilación.
Estas excepciones ocurren debido a una mala programación, el programa no
dará un error de compilación y todas las excepciones no verificadas son
subclases directas de la clase RuntimeException.

A continuación se muestran los tipos de excepciones no marcadas:

● NullPointerException
● ArrayIndexOutOfBound
● IllegalArgumentException
● IllegalStateException
La excepción verificada es aquella que se verifica en tiempo de compilación
llamada Excepción comprobada, si algún código dentro de un método lanza
una excepción marcada, entonces el método debe manejarla o debe
especificarse usando la sentencia reservada throws.

La excepción verificada es aquella que se verifica en tiempo de compilación

llamada Excepción comprobada, si algún código dentro de un método lanza
una excepción marcada, entonces el método debe manejarla o debe
especificarse usando la sentencia reservada throws.
A continuación se muestran los tipos de excepciones marcadas:

● IOException
● SQLException
● DataAccessException
● ClassNotFoundException
● InvocationTargetException
● MalformedURLException

Handling Exceptions
 try...catch

El bloque try contiene un conjunto de declaraciones donde puede ocurrir

una excepción. Un bloque try (prueba) siempre es seguido por un bloque
catch (captura), que maneja la excepción que ocurre en el bloque de try
asociado. Un bloque de try debe ser seguido por bloques de captura o
finally o por ambos.

try

try{
//esta linea lanza una excepcion.
}
 try...catch

Mientras escribimos un programa, si creemos que ciertas declaraciones en

una rutina pueden generar una excepción, debemos encerrarlas en el bloque
try y para manejar esa excepción.

Catch

Un bloque catch es donde manejas las excepciones, este bloque debe

seguir al bloque try. Un solo bloque de try puede tener varios bloques
catch asociados. Puede capturar diferentes excepciones en diferentes
bloques de captura.
Cuando ocurre una excepción en el bloque try, se ejecuta el bloque catch
correspondiente que maneja esa excepción particular.
Por ejemplo, si se produce una excepción aritmética en el bloque try , se
ejecutan las instrucciones incluidas en el bloque catch para la excepción
aritmética.
 try
//Bloque 1
try{
//Bloque 2
}catch(Exception ex){
//Bloque 3
}
//Bloque 4

try...Catch

Bloque 1 Bloque 2 Bloque 4

 try...Catch

Bloque 1 Bloque 2 Bloque 3 Bloque 4

try...Catch

Bloque 1
 try
//Bloque 1
try{
//Bloque 2
}catch(AritmeticException ae){
//Bloque 3
}catch(NullPointerException ne){
//Bloque 4
}
//Bloque 5

try...Catch

Bloque 1 Bloque 2 Bloque 5

 try...Catch

Bloque 1 Bloque 2 Bloque 3 Bloque 5

try...Catch

Bloque 1 Bloque 2 Bloque 4 Bloque 5

 try...Catch

Bloque 1 Bloque 2
 Finally

En ocasiones, nos interesa ejecutar un fragmento de código

independientemente de si se produce o no una excepción, y puede ser usado
si queremos por ejemplo cerrar una conexión con un archivo que tuviéramos
abierto, o con una base de datos, o para vaciar búferes.

finally
//Bloque 1
try{
//Bloque 2
}catch(AritmeticException ae){
//Bloque 3

}finally{
//Bloque 4
}
//Bloque 5
5

thows

throws
Si un método es capaz de provocar una excepción que no maneja él mismo,
debería especificar este comportamiento, para que todos los métodos que lo
llamen puedan colocar protecciones frente a esa excepción.
La sentencia throws se utiliza para identificar la lista posible de excepciones
que un método puede lanzar.
Si un método lanza explícitamente una instancia de Exception o de sus
subclases, se debe declarar su tipo con la sentencia throws.
 throws
Cuando se lanza una excepción:
● Se sale inmediatamente del bloque de código actual
● Si el bloque tiene asociada una cláusula catch adecuada para el tipo de la
excepción generada, se ejecuta el cuerpo de la cláusula catch.
● Si no, se sale del bloque (o método) dentro del cual se produjo la
excepción y se busca una cláusula catch apropiada.
● El proceso continúa hasta llegar al método main de la aplicación si ahí no
tampoco existe una cláusula catch adecuada, la máquina virtual Java
finaliza su ejecución con un mensaje de error.

throws

public String f(String nombreArchivo) throws IOException{

//rutina que puede
//lanzar una excepcion de tipo IOException
}
6

thow

throw
La sentencia throw se utiliza para lanzar explícitamente una excepción. En
primer lugar se debe obtener un descriptor de un objeto Throwable, bien
mediante un parámetro en una cláusula catch o, se puede crear utilizando el
operador new.
El flujo de la ejecución se detiene inmediatamente después de la sentencia
throw, y nunca se llega a la sentencia siguiente. Se inspecciona el bloque
try que la engloba más cercano, para ver si tiene la cláusula catch cuyo tipo
coincide con el del objeto o instancia Thorwable. Si se encuentra, el control se
transfiere a ese sentencia. Si no, se inspecciona el siguiente bloque try que la
engloba, y así sucesivamente.
 throw

public String f(String nombreArchivo){

//sentencias
throw new ObjetoThrowable();
//sentencias
}

Multithreading
Los sistemas operativos son multitarea, lo que les permite ejecutar diversos
procesos de forma simultánea. Esta capacidad ha permitido el hecho de
optimizar la programación hacia modelos multiproceso o multihilo.

Típicamente cuando desarrollo una rutina esperamos que esta sea ejecuta de
forma secuencial una tras otra, pero que sí necesitamos que las tareas se
ejecuten de forma paralela?

Los sistemas operativos multitarea ejecutan o emulan ejecutar más de una

tarea a la vez. Esto es solo cierto si dispone de más de un procesador, si no, va
alternando procesos en un solo procesador.

La ejecución de un proceso implica que el mismo en el momento de

ejecución utiliza todo el procesador y con el espacio de memoria asignado. En
sistemas multitarea, se van alternando procesos y cuando uno libera el
procesador para que otro se ejecute, también libera la memoria asignada.
La programación multihilo se basa en que, dentro del desarrollo de la
aplicación, hemos definido diversas tareas para que se ejecuten a la vez.
Todas estas tareas forman parte de un mismo proceso.

Para el sistema operativo tendremos un solo proceso con diversas tareas a

ejecutar. En este sentido el planificador se encarga de que cuando le toque
ejecutarse a nuestro proceso, las tareas del mismo se vayan alternando, con
la diferencia que, al ser de un mismo proceso, no se libera espacio de
memoria ni procesador, como si se haría en el caso de alternar procesos.

A diferencia de muchos otros lenguajes de programación, Java proporciona

soporte integrado para subprocesos múltiples. El subprocesamiento múltiple
en Java contiene dos o más partes que pueden ejecutarse simultáneamente.
Un hilo de Java es en realidad un proceso ligero.
● Mayor rendimiento: ya que podemos ejecutar tareas que emulan el
paralelismo, aunque en algunos casos el uso excesivo puede eliminar
cualquier ganancia de rendimiento y resulte en peor rendimiento que en
un escenario de proceso único.
● Aplicaciones receptivas que dan la ilusión de multitarea.
● Utilización eficiente de los recursos. Tenga en cuenta que la creación de
subprocesos es ligera en comparación con generar un proceso
completamente nuevo.

El hecho de usar programación multihilo no implica que siempre vamos a

tener una mejora de rendimiento y por diseño como se debe decidir cuándo
conviene usar el multitheading. En líneas generales, si tarea a desarrollar es
muy simple no tiene sentido plantearse este tipo de programación.

Tampoco puede que sea buena idea emplear el multihilo para tareas
excesivamente complejas pues provocará excesiva sobrecarga y sea más un
problema que una ventaja.
se considera que una aplicación es candidata a ser programa en multihilo
cuando cumple las siguientes premisas:
● Se requiere realizar diversas tareas claramente diferenciadas.
● El resultado de las tareas que se ejecuten en diferentes hilos no debe
depender del resultado de otras tareas, ya que, de lo contrario, las tareas
se estarían esperando unas a otras y al final el rendimiento sería menor
del esperado.
● Se prevea que pueda haber tareas retenidas o bloqueadas por estar
esperando a una lectura de disco, por ejemplo. En estos casos, esta tarea
se bloquea y otra entra en acción, aprovechando de esta forma la
programación multihilo.

Conozcamos las diferencias entre:

● un programa,
● un proceso
● un hilo.
Un programa es un conjunto de instrucciones y datos asociados que residen
en el disco y que el sistema operativo carga para realizar alguna tarea. Un
archivo ejecutable o un archivo de script de Python son ejemplos de
programas. Para ejecutar un programa, primero se le pide al núcleo del
sistema operativo que cree un nuevo proceso, que es un entorno en el que se
ejecuta un programa.

Un proceso es un programa en ejecución. Un proceso es un entorno de

ejecución que consta de instrucciones, datos de usuario y segmentos de
datos del sistema, así como muchos otros recursos como CPU, memoria,
espacio de direcciones, disco y E / S de red adquiridos en tiempo de
ejecución. Un programa puede tener varias copias ejecutándose al mismo
tiempo, pero un proceso necesariamente pertenece a un solo programa.
Thread es la unidad de ejecución más pequeña en un proceso. Un hilo
simplemente ejecuta instrucciones en serie. Un proceso puede tener
múltiples hilos ejecutándose como parte de él. Por lo general, habría algún
estado asociado con el proceso que se comparte entre todos los
subprocesos y, a su vez, cada subproceso tendría algún estado privado para sí
mismo. El estado globalmente compartido entre los hilos de un proceso es
visible y accesible para todos los hilos, y se debe prestar especial atención
cuando cualquier hilo intenta leer o escribir en este estado compartido global.
Hay varios constructos ofrecidos por varios lenguajes de programación para
proteger y disciplinar el acceso a este estado global, que detallaremos en las
próximas lecciones.
8
Hilos y Multithreading
en Java
Threads and Multithreading

Normalmente trabajamos con programas lineales. En los ejemplos

planteados anteriormente, podemos ver la secuencia en que las instrucciones
se ejecutan, una tras otra.
Sin embargo, para cierto tipo de programas mantener un flujo lineal de sus
instrucciones no resulta del todo eficiente y tendremos que pensar en la
posibilidad de que diferentes porciones de código se ejecuten
concurrentemente.
En Java un thread es una clase que extiende a la clase base Thread, de la cual
hereda el método run. Este método es secuencial y es allí donde debemos
programar la tarea que queremos que nuestro hilo lleve a cabo.

Los hilos existen en varios estados:

new: cuando creamos una instancia de la clase Thread, un hilo está en un nuevo
estado.
Running: el hilo de Java está en estado de ejecución.
Suspended: se puede suspender un subproceso en ejecución, lo que suspende
temporalmente su actividad. Luego se puede reanudar un hilo suspendido,
permitiéndole retomar donde lo dejó.
Blocked: un subproceso Java puede bloquearse cuando se espera un recurso.
Terminated: un subproceso se puede terminar, lo que detiene su ejecución
inmediatamente en cualquier momento. Una vez que se termina un subproceso,
no se puede reanudar.
Los hilos existen en varios estados:
new: cuando creamos una instancia de la clase Thread, un hilo está en un nuevo
estado.
Running: el hilo de Java está en estado de ejecución.
Suspended: se puede suspender un subproceso en ejecución, lo que suspende
temporalmente su actividad. Luego se puede reanudar un hilo suspendido,
permitiéndole retomar donde lo dejó.
Blocked: un subproceso Java puede bloquearse cuando se espera un recurso.
Terminated: un subproceso se puede terminar, lo que detiene su ejecución
inmediatamente en cualquier momento. Una vez que se termina un subproceso,
no se puede reanudar.

New

Runnable

Non Runnable
(Blocked)

Runnning

Salimos del método

run()

Terminated
 Thread Runnable
La clase Thread define varios métodos que ayudan a administrar hilos:

Metodo Descripción

getName Obtiene el nombre del hilo

getPriority Obtiene la prioridad del hilo

isAlive Determina si el hilo aun se esta ejecutando

join Espera mientras termina un hilo

run Punto de entrada de el hilo

sleep Suspende el hilo por un periodo determinado

start Inicia un hilo invocando su método run

Cuando iniciamos un programa Java, un hilo se inicia inmediatamente, este hilo

es llamado hilo principal o Main thread del el programa.

El hilo principal es creado inmediatamente cuando el programa es iniciado.

● Porque afecta a los otros hilos 'secundarios'.

● Porque realiza varias acciones de apagado.

● Porque se crea automáticamente cuando se inicia su programa.

Thread Runnable

El sistema multiproceso de Java se basa en la clase Thread, sus métodos y su

interfaz complementaria, Runnable. Para crear un nuevo hilo, el programa
debera extender (extends) Thread o implementar (implements) la interfaz
Runnable.
Java le permite crear un hilo de dos maneras:
● Mediante la implementación de la interfaz Runnable.
● Al extender la clase Thread.
 Thread

La forma más directa para hacer un programa multihilo es extender la clase

Thread, y redefinir el método run().
El método run() es secuencial y es ahí donde debemos programar el código
que se ejecuta dentro del nuevo hilo.

public void run(){}

El método run() es invocado cuando se inicia el hilo (mediante una llamada al

método start() de la clase Thread). El hilo se inicia con la llamada al método
run() y termina cuando termina éste.

Thread

public class DemoThread extends Thread{

public void run(){

//codigo a ejecutar en el hilo
}

}
 run

La ejecución del método run de un Thread puede ejecutarse

concurrentemente con otros métodos run de otros Thread y con el método
main.

Obj A Obj B Obj C

main()
run() run() run()

start()

El inicio de la ejecución de una tarea se realiza mediante el método

start()heredado de Thread

start()es un método especial que invoca a run() y devuelve inmediatamente

el control a la tarea que lo ha llamado.
 En el siguiente ejemplo, la clase extiende a Thread sobrescribe el método run
y dentro de este hace dos cosas:
● “Duerme” una cantidad aleatoria de milisegundos (entre 0 y 4999).
● Cuando se “despierta” escribe en la pantalla el nombre que recibió como
parámetro en el constructor y muestra cuánto tiempo durmió.

currentThread()

currentThread() is a static method , returns a reference to the currently

executing thread object.
 getId()

getId() will return the unique identifier of current thread which is a positive
long value.

En el siguiente ejemplo, Muestra el id del hilo que está corriendo en ese

momento.
 Thread(String str)

El constructor public Thread(String str) recibe un parámetro que es la

identificación del Thread.

getName()

El metodo getName() devuelve el nombre del Thread (el que se ha pasado

como argumento al constructor).
En el siguiente ejemplo, Muestra pasa como parámetro un nombre identificador
para el hilo y no imprime en pantalla según se vaya ejecutando.

sleep()

El metodo getName() devuelve el nombre del Thread (el que se ha pasado

como argumento al constructor).
En el siguiente ejemplo, duerme el hilo por un tiempo ramdom.

9
Asignar prioridades a los
hilos
Threads Priority
Cada hilo tiene asociada una configuración de prioridad. La prioridad de un hilo
determina, en parte, cuánto tiempo de CPU recibe un hilo en relación con los
otros hilos activos.

Cuando se inicia un hilo secundario, su configuración de prioridad es igual a la

de su hilo principal. Puede cambiar la prioridad de un hilo llamando a
setPriority(), que es un miembro de Thread, si queremos cambiar la
prioridad de un hilo lo hacemos con el método setPriority().

Este método arroja IllegalArgumentException si el valor del parámetro nivel va

más allá del límite mínimo (1) y máximo (10).

El nivel especifica la configuración de prioridad para el hilo de llamada. El valor

del nivel debe estar dentro del rango MIN_PRIORITY y MAX_PRIORITY. y estos
valores son 1 y 10, respectivamente.

Para devolver un hilo a la prioridad predeterminada, especifique

NORM_PRIORITY, que actualmente es 5. Estas prioridades se definen como
variables finales estáticas dentro de Thread.
public static int MIN_PRIORITY: esta es la prioridad mínima que un hilo puede
tener. El valor es 1.

public static int NORM_PRIORITY: esta es la prioridad predeterminada de un

hilo si no lo define explícitamente. El valor es 5.

public static int MAX_PRIORITY: esta es la prioridad máxima de un hilo. El valor

es 10.

En el siguiente ejemplo, obtiene la prioridad de los hilos el hilo con la mayor

prioridad tiene mayor probabilidad de ejecutarse antes que los otros hilos.
En el siguiente ejemplo, obtiene la prioridad de los hilos el hilo con la mayor
prioridad tiene mayor probabilidad de ejecutarse antes que los otros hilos.

https://javadesdecero.es/avanzado/prioridad-de-hilos/

9
¿Cómo saber si un hilo ha
finalizado?
Threads
 El hilo proporciona un medio por el cual saber el estado de un hilo. Java
multi-threading proporciona dos formas de encontrar eso:

● isAlive()
● join()

isAlive()

El metodo isAlive () prueba si este hilo está vivo. Un hilo está vivo si se ha
iniciado y aún no ha muerto.
Hay un período de transición desde el momento en que se ejecuta un
subproceso hasta cuando no se ejecuta un subproceso. Si queremos saber si se
ha llamado al método de inicio del hilo o si se ha terminado el hilo, debemos
usar el método isAlive(). Este método se utiliza para saber si un subproceso
se ha iniciado realmente y aún no ha terminado.
 join()

El método se usa para esperar a que termine un hilo se llama join(). Este
método espera hasta que el hilo en el que se llama termina. Las formas
adicionales de join() le permiten especificar la cantidad máxima de tiempo
que desea esperar a que termine el subproceso especificado.

Runnable

A veces no es conveniente extender la clase Thread porque se pierde la

posibilidad de extender otro objeto. Es una de las razones por que existe la
interfaz Runnable que declara nada más que el método public void run() y que
se puede usar fácilmente para crear hilos trabajadores.

La interfaz Runnable exige solamente el método run(), sin embargo,

normalmente se implementan más métodos para crear un servicio completo
que este hilo debe cumplir.
 Runnable

Existen cuatro constructores para crear hilos usando la interfaz Runnable.

public Thread(Runnable target): se pasa solamente la implementación
de la interfaz Runnable.
public Thread(Runnable target, String name):se pasa
adicionalmente un nombre para el hilo.
public Thread(ThreadGroup group, Runnable target):construye un
hilo dentro de un grupo de hilos.
public Thread(ThreadGroup group, Runnable target, String
name):construye un hilo con nombre dentro de un grupo de hilos.

¿Preguntas?